def _verify_acl_traffic(self, setup, direction, ptfadapter, pkt, dropped,
ip_version):
exp_pkt = self.expected_mask_routed_packet(pkt, ip_version)
if ip_version == "ipv4":
downstream_dst_port = DOWNSTREAM_IP_PORT_MAP.get(
pkt[packet.IP].dst)
else:
downstream_dst_port = DOWNSTREAM_IP_PORT_MAP.get(
pkt[packet.IPv6].dst)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, self.src_port, pkt)
if direction == "uplink->downlink" and downstream_dst_port:
if dropped:
testutils.verify_no_packet(ptfadapter, exp_pkt,
downstream_dst_port)
else:
testutils.verify_packet(ptfadapter, exp_pkt,
downstream_dst_port)
else:
if dropped:
testutils.verify_no_packet_any(ptfadapter,
exp_pkt,
ports=self.get_dst_ports(
setup, direction))
else:
testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=self.get_dst_ports(
setup, direction),
timeout=20)
def run_test_ipv4(ptfadapter, facts):
logger.info("Running test with ipv4 packets")
pkt = testutils.simple_udp_packet(eth_dst=facts['src_router_mac'],
eth_src=facts['src_host_mac'],
ip_src=facts['dst_host_ipv4'],
ip_dst=facts['dst_host_ipv4'],
ip_ttl=DEFAULT_HLIM_TTL)
logger.info("\nSend Packet:\neth_dst: {}, eth_src: {}, ipv4 ip: {}".format(
facts['src_router_mac'], facts['src_host_mac'],
facts['dst_host_ipv4']))
testutils.send(ptfadapter, facts['src_port_ids'][0], pkt)
exp_pkt = testutils.simple_udp_packet(eth_dst=facts['dst_host_mac'],
eth_src=facts['dst_router_mac'],
ip_src=facts['dst_host_ipv4'],
ip_dst=facts['dst_host_ipv4'],
ip_ttl=DEFAULT_HLIM_TTL - 1)
logger.info(
"\nExpect Packet:\neth_dst: {}, eth_src: {}, ipv4 ip: {}".format(
facts['dst_host_mac'], facts['dst_router_mac'],
facts['dst_host_ipv4']))
testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
facts['dst_port_ids'],
timeout=WAIT_EXPECTED_PACKET_TIMEOUT)
def generate_and_verify_traffic(duthost, ptfadapter, ip_dst, expected_ports, ipv6=False):
if ipv6:
pkt = testutils.simple_tcpv6_packet(
eth_dst=duthost.facts["router_mac"],
eth_src=ptfadapter.dataplane.get_mac(0, 0),
ipv6_src='2001:db8:85a3::8a2e:370:7334',
ipv6_dst=ip_dst,
ipv6_hlim=64,
tcp_sport=1234,
tcp_dport=4321)
else:
pkt = testutils.simple_tcp_packet(
eth_dst=duthost.facts["router_mac"],
eth_src=ptfadapter.dataplane.get_mac(0, 0),
ip_src='1.1.1.1',
ip_dst=ip_dst,
ip_ttl=64,
tcp_sport=1234,
tcp_dport=4321)
exp_pkt = pkt.copy()
exp_pkt = mask.Mask(exp_pkt)
exp_pkt.set_do_not_care_scapy(packet.Ether, 'dst')
exp_pkt.set_do_not_care_scapy(packet.Ether, 'src')
if ipv6:
exp_pkt.set_do_not_care_scapy(packet.IPv6, 'hlim')
exp_pkt.set_do_not_care_scapy(packet.IPv6, 'chksum')
else:
exp_pkt.set_do_not_care_scapy(packet.IP, 'ttl')
exp_pkt.set_do_not_care_scapy(packet.IP, 'chksum')
testutils.send(ptfadapter, 5, pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=expected_ports)
def send_and_verify_packet(ptfadapter, packet, expected_packet, tx_port, rx_ports, exp_recv):
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, pkt=packet, port_id=tx_port)
if exp_recv:
testutils.verify_packet_any_port(ptfadapter, pkt=expected_packet, ports=rx_ports, timeout=5)
else:
testutils.verify_no_packet_any(ptfadapter, pkt=expected_packet, ports=rx_ports)
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 send_recv_ping_packet(ptfadapter, ptf_send_port, ptf_recv_ports, dst_mac,
src_ip, dst_ip):
pkt = testutils.simple_icmp_packet(eth_dst=dst_mac,
ip_src=src_ip,
ip_dst=dst_ip,
icmp_type=8,
icmp_data="")
ext_pkt = pkt.copy()
ext_pkt['Ether'].src = dst_mac
masked_exp_pkt = Mask(ext_pkt)
masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "tos")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "len")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "id")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "flags")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "frag")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "ttl")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "chksum")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "code")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "chksum")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "id")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "seq")
logger.info(
'send ping request packet send port {}, recv port {}, dmac: {}, dip: {}'
.format(ptf_send_port, ptf_recv_ports, dst_mac, dst_ip))
testutils.send(ptfadapter, ptf_send_port, pkt)
testutils.verify_packet_any_port(ptfadapter,
masked_exp_pkt,
ptf_recv_ports,
timeout=WAIT_EXPECTED_PACKET_TIMEOUT)
def run_test_ipv4(ptfadapter, gather_facts):
logger.info("Running test with ipv4 packets")
dst_host_ipv4 = str(
ip_address(unicode(gather_facts['dst_router_ipv4'])) + 1)
pkt = testutils.simple_udp_packet(eth_dst=gather_facts['src_router_mac'],
eth_src=gather_facts['src_host_mac'],
ip_src=dst_host_ipv4,
ip_dst=dst_host_ipv4,
ip_ttl=DEFAULT_HLIM_TTL)
logger.info("\nSend Packet:\neth_dst: {}, eth_src: {}, ipv6 ip: {}".format(
gather_facts['src_router_mac'], gather_facts['src_host_mac'],
dst_host_ipv4))
testutils.send(ptfadapter, int(gather_facts['src_port_ids'][0]), pkt)
pkt = testutils.simple_udp_packet(eth_dst=gather_facts['dst_host_mac'],
eth_src=gather_facts['dst_router_mac'],
ip_src=dst_host_ipv4,
ip_dst=dst_host_ipv4,
ip_ttl=DEFAULT_HLIM_TTL - 1)
logger.info(
"\nExpect Packet:\neth_dst: {}, eth_src: {}, ipv6 ip: {}".format(
gather_facts['dst_host_mac'], gather_facts['dst_router_mac'],
dst_host_ipv4))
port_list = [int(port) for port in gather_facts['dst_port_ids']]
testutils.verify_packet_any_port(ptfadapter,
pkt,
port_list,
timeout=WAIT_EXPECTED_PACKET_TIMEOUT)
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 generate_and_verify_traffic(duthost, ptfadapter, src_port, dst_port,
ip_src, ip_dst, pkt_action):
"""
Send ICMP request packet from PTF to DUT and
verify that DUT sends/doesn't send ICMP reply packet to PTF.
Args:
duthost: DUT host object
ptfadapter: PTF adapter
src_port: Port of PTF
dst_port: Port of DUT
ip_src: Source IP address of PTF
ip_dst: Destination IP address of DUT
pkt_action: Packet action (forwarded or drop)
"""
router_mac = get_mac_dut(duthost, dst_port)
src_port_number = int(get_port_number(src_port))
src_mac = ptfadapter.dataplane.get_mac(0, src_port_number)
# Get VLAN ID from name of sub-port
vlan_vid = int(src_port.split('.')[1])
ip_src = ip_src.split('/')[0]
ip_dst = ip_dst.split('/')[0]
# Create ICMP request packet
pkt = create_packet(eth_dst=router_mac,
eth_src=src_mac,
ip_src=ip_src,
ip_dst=ip_dst,
vlan_vid=vlan_vid,
dl_vlan_enable=True)
# Define ICMP reply packet
exp_pkt = create_packet(eth_src=router_mac,
eth_dst=src_mac,
ip_src=ip_dst,
ip_dst=ip_src,
vlan_vid=vlan_vid,
dl_vlan_enable=True,
icmp_type=0)
masked_exp_pkt = mask.Mask(exp_pkt)
masked_exp_pkt.set_do_not_care_scapy(packet.IP, "id")
masked_exp_pkt.set_do_not_care_scapy(packet.IP, "chksum")
masked_exp_pkt.set_do_not_care_scapy(packet.IP, "ttl")
masked_exp_pkt.set_do_not_care_scapy(packet.ICMP, "chksum")
ptfadapter.dataplane.flush()
testutils.send_packet(ptfadapter, src_port_number, pkt)
dst_port_list = [src_port_number]
if pkt_action == ACTION_FWD:
testutils.verify_packet_any_port(ptfadapter, masked_exp_pkt,
dst_port_list)
elif pkt_action == ACTION_DROP:
testutils.verify_no_packet_any(ptfadapter, masked_exp_pkt,
dst_port_list)
def _verify_acl_traffic(self, setup, direction, ptfadapter, pkt, dropped):
exp_pkt = self.expected_mask_routed_packet(pkt)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
if dropped:
testutils.verify_no_packet_any(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
else:
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
def test_rules_priority_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test rules priorities, forward rule case """
pkt = self.tcp_packet(setup, direction, ptfadapter)
pkt['IP'].src = '20.0.0.7'
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(20)
def test_icmp_source_ip_match_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test ICMP source IP matched packet forwarded """
pkt = self.icmp_packet(setup, direction, ptfadapter)
pkt['IP'].src = '20.0.0.4'
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(12)
def test_l4_dport_match_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test L4 destination port matched packet forwarded """
pkt = self.tcp_packet(setup, direction, ptfadapter)
pkt['TCP'].dport = 0x1217
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(5)
def test_l4_sport_range_match_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test L4 source port range matched packet forwarded """
pkt = self.tcp_packet(setup, direction, ptfadapter)
pkt['TCP'].sport = 0x123A
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(10)
def test_ip_proto_match_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test IP protocol matched packet forwarded"""
pkt = self.tcp_packet(setup, direction, ptfadapter)
pkt['IP'].proto = 0x7E
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(5)
def test_tcp_flags_match_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test TCP flags matched packet forwarded """
pkt = self.tcp_packet(setup, direction, ptfadapter)
pkt['TCP'].flags = 0x1B
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(6)
def test_dest_ip_match_forwarded(self, setup, direction, ptfadapter, counters_sanity_check):
""" test destination IP matched packet forwarded """
pkt = self.tcp_packet(setup, direction, ptfadapter)
pkt['IP'].dst = DST_IP_TOR_FORWARDED if direction == 'spine->tor' else DST_IP_SPINE_FORWARDED
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
counters_sanity_check.append(2 if direction == 'spine->tor' else 3)
def test_bgpmon(duthost, common_setup_teardown, ptfadapter):
"""
Add a bgp monitor on ptf and verify that DUT is attempting to establish connection to it
"""
local_addr, peer_addr, peer_ports = common_setup_teardown
exp_packet = build_syn_pkt(local_addr, peer_addr)
# Load bgp monitor config
logger.info(
"Configured bgpmon and verifying packet on {}".format(peer_ports))
duthost.command("sonic-cfggen -j {} -w".format(BGPMON_CONFIG_FILE))
# Verify syn packet on ptf
testutils.verify_packet_any_port(test=ptfadapter,
pkt=exp_packet,
ports=peer_ports,
timeout=BGP_CONNECT_TIMEOUT)
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 __exit__(self, *exc_info):
if exc_info[0]:
return
try:
port_index, rec_pkt = testutils.verify_packet_any_port(
ptfadapter,
self.exp_pkt,
ports=self.listen_ports
)
except AssertionError as detail:
logging.debug("Error occurred in polling for tunnel traffic", exc_info=True)
if "Did not receive expected packet on any of ports" in str(detail):
if self.existing:
raise detail
else:
raise detail
else:
self.rec_pkt = Ether(rec_pkt)
rec_port = self.listen_ports[port_index]
logging.debug("Receive encap packet from PTF interface %s", "eth%s" % rec_port)
logging.debug("Encapsulated packet:\n%s", self._dump_show_str(self.rec_pkt))
if not self.existing:
raise RuntimeError("Detected tunnel traffic from host %s." % self.standby_tor.hostname)
ttl_check_res = self._check_ttl(self.rec_pkt)
tos_check_res = self._check_tos(self.rec_pkt)
check_res = []
if ttl_check_res:
check_res.append(ttl_check_res)
if tos_check_res:
check_res.append(tos_check_res)
if check_res:
raise ValueError(", ".join(check_res) + ".")
def test_push_label(self, setup, ptfadapter):
""" test push label """
dst_pid = setup['dst_pid']
src_pid = setup['src_pid']
self.config_interface_mpls(setup, LABEL_PUSH_ROUTES)
time.sleep(2)
pkt = self.icmp_packet(setup, ptfadapter)
epkt = pkt.copy()
pkt1 = epkt['IP']
epkt['Ethernet'].type = 0x8847
epkt['Ethernet'].remove_payload()
mp = MPLS(label=1000002, s=1, ttl=255)
mp.remove_payload()
epkt /= mp
epkt /= pkt1
exp_pkt = self.expected_mask_mpls_push_packet(epkt, 1000001)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, src_pid, pkt)
try:
res = testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=[dst_pid])
logger.info(res)
except Exception as e:
self.teardown_labels(setup)
pytest.fail('MPLS push test failed \n' + str(e))
self.teardown_labels(setup)
def test_swap_labelstack(self, setup, ptfadapter):
""" test swap labelstack """
dst_pid = setup['dst_pid']
src_pid = setup['src_pid']
self.config_interface_mpls(setup, LABEL_SWAP_ROUTES)
time.sleep(2)
pkt = self.mpls_stack_packet(setup, ptfadapter)
exp_pkt = self.expected_mask_mpls_swap_packet(pkt, 1000002)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, src_pid, pkt)
try:
res = testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=[dst_pid])
logger.info(res)
except Exception as e:
self.teardown_labels(setup)
pytest.fail('MPLS swap labelstack test failed \n' + str(e))
self.teardown_labels(setup)
def test_decap_active_tor(apply_active_state_to_orchagent,
build_encapsulated_packet, rand_selected_interface,
ptfadapter, tbinfo, rand_selected_dut,
tunnel_traffic_monitor):
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet)
ptfadapter.dataplane.flush()
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
testutils.send(ptfadapter,
int(ptf_t1_intf.strip("eth")),
encapsulated_packet,
count=10)
_, rec_pkt = testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=[exp_ptf_port_index])
rec_pkt = Ether(rec_pkt)
logging.info("received decap packet:\n%s",
tunnel_traffic_monitor._dump_show_str(rec_pkt))
exp_ttl = encapsulated_packet[IP].payload[IP].ttl - 1
exp_tos = encapsulated_packet[IP].payload[IP].tos
if rec_pkt[IP].ttl != exp_ttl:
pytest.fail("the expected ttl should be %s" % exp_ttl)
if rec_pkt[IP].tos != exp_tos:
pytest.fail("the expected tos should be %s" % exp_tos)
def send_and_verify(self,
dst_ip,
expected_ports,
src_port,
outer_pkt='ipv4',
triple_encap=False,
outer_ttl=None,
inner_ttl=None):
'''
@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
@outer_ttl: TTL for the outer layer
@inner_ttl: TTL for the inner layer
'''
pkt, exp_pkt = self.create_encap_packet(dst_ip, outer_pkt,
triple_encap, outer_ttl,
inner_ttl)
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_port, source_mac, dest_port, dest_mac):
"""
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
:return:
"""
pkt = testutils.simple_eth_packet(eth_dst=dest_mac,
eth_src=source_mac,
eth_type=DEFAULT_FDB_ETHERNET_TYPE)
logger.debug(
'send packet src port {} smac: {} dmac: {} verifying on dst port {}'.
format(source_port, source_mac, dest_mac, dest_port))
testutils.send(ptfadapter, source_port, pkt)
testutils.verify_packet_any_port(ptfadapter, pkt, [dest_port])
def test_push_label(self, setup, ptfadapter):
""" test push MPLS label """
duthost = setup['duthost']
# Copy APP_DB config to DUT
duthost.copy(src=os.path.join(ADD_DIR, LABEL_PUSH_ROUTES),
dest=setup['dut_tmp_dir'])
label_add_dut_path = os.path.join(setup['dut_tmp_dir'],
LABEL_PUSH_ROUTES)
# Apply routes with swssconfig
result = duthost.shell(
'docker exec -i swss swssconfig /dev/stdin < {}'.format(
label_add_dut_path),
module_ignore_errors=True)
if result['rc'] != 0:
pytest.fail(
'Failed to apply labelroute configuration file: {}'.format(
result['stderr']))
# Create packet for sending and masked expected packet on receiving port
pkt = self.icmp_packet(setup, ptfadapter)
## Add MPLS header in expected packet
epkt = pkt.copy()
pkt1 = epkt['IP']
epkt['Ether'].type = 0x8847
epkt['Ether'].remove_payload()
mp = MPLS(label=1000002, s=1, ttl=255)
mp.remove_payload()
epkt /= mp
epkt /= pkt1
exp_pkt = self.expected_mask_mpls_push_packet(epkt, 1000001)
ptfadapter.dataplane.flush()
# Send pkt from spine port 10
testutils.send(ptfadapter, '10', pkt)
# Capture and verify packets on tor port 25
res = testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=[25])
# Copy Delete MPLS configs to DUT after test
duthost.copy(src=os.path.join(ADD_DIR, LABEL_DEL_ROUTES),
dest=setup['dut_tmp_dir'])
label_del_dut_path = os.path.join(setup['dut_tmp_dir'],
LABEL_DEL_ROUTES)
# Apply routes with swssconfig
result = duthost.shell(
'docker exec -i swss swssconfig /dev/stdin < {}'.format(
label_del_dut_path),
module_ignore_errors=True)
if result['rc'] != 0:
pytest.fail(
'Failed to apply labelroute configuration file: {}'.format(
result['stderr']))
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 runTestIpv4(self):
self.test.log("Run IPv4 based test")
pkt = simple_udp_packet(eth_dst=self.srcRouterMac,
eth_src=self.srcHostMac,
ip_src=self.dstHostIpv4,
ip_dst=self.dstHostIpv4,
ip_ttl=self.pktTtlHlim)
send(self.test, int(self.srcPortIds[0]), pkt)
pkt = simple_udp_packet(eth_dst=self.dstHostMac,
eth_src=self.dstRouterMac,
ip_src=self.dstHostIpv4,
ip_dst=self.dstHostIpv4,
ip_ttl=self.pktTtlHlim-1)
verify_packet_any_port(self.test, pkt, [int(port) for port in self.dstPortIds])
self.test.log("IPv4 based test: done")
def test_dscp_to_queue_during_decap_on_active(
ptfhost, setup_dualtor_tor_active, build_encapsulated_ip_packet,
request, rand_selected_interface, ptfadapter, tbinfo,
rand_selected_dut, tunnel_traffic_monitor, duthosts,
rand_one_dut_hostname):
"""
Test if DSCP to Q mapping for inner header is matching with outer header during decap on active
"""
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_ip_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet)
# Clear queue counters
duthost = duthosts[rand_one_dut_hostname]
duthost.shell('sonic-clear queuecounters')
logging.info("Clearing queue counters before starting traffic")
with stop_garp(ptfhost):
ptfadapter.dataplane.flush()
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
testutils.send(ptfadapter,
int(ptf_t1_intf.strip("eth")),
encapsulated_packet,
count=10)
exp_tos = encapsulated_packet[IP].payload[IP].tos
exp_dscp = exp_tos >> 2
exp_queue = derive_queue_id_from_dscp(exp_dscp)
_, rec_pkt = testutils.verify_packet_any_port(
ptfadapter, exp_pkt, ports=[exp_ptf_port_index], timeout=10)
rec_pkt = Ether(rec_pkt)
logging.info("received decap packet:\n%s",
dump_scapy_packet_show_output(rec_pkt))
time.sleep(10)
rec_queue = get_queue_id_of_received_packet(duthosts,
rand_one_dut_hostname,
rand_selected_interface)
if rec_queue == None or rec_queue != exp_queue:
pytest.fail(
"the expected Queue : {} not matching with received Queue : {}"
.format(exp_queue, rec_queue))
else:
logging.info(
"the expected Queue : {} matching with received Queue : {}".
format(exp_queue, rec_queue))
def test_swap_labelstack(self, setup, ptfadapter):
""" test swap for stack of 3 MPLS label """
duthost = setup['duthost']
# Copy APP_DB config to DUT
duthost.copy(src=os.path.join(ADD_DIR, LABEL_SWAP_ROUTES),
dest=setup['dut_tmp_dir'])
label_add_dut_path = os.path.join(setup['dut_tmp_dir'],
LABEL_SWAP_ROUTES)
# Apply routes with swssconfig
result = duthost.shell(
'docker exec -i swss swssconfig /dev/stdin < {}'.format(
label_add_dut_path),
module_ignore_errors=True)
if result['rc'] != 0:
pytest.fail(
'Failed to apply labelroute configuration file: {}'.format(
result['stderr']))
# Create packet for sending and masked expected packet on receiving port
pkt = self.mpls_stack_packet(setup, ptfadapter)
exp_pkt = self.expected_mask_mpls_swap_packet(pkt, 1000002)
ptfadapter.dataplane.flush()
# Send pkt from spine port 10
testutils.send(ptfadapter, '10', pkt)
# Capture and verify packets on tor port 25
res = testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=[25])
# Copy Delete MPLS configs to DUT after test
duthost.copy(src=os.path.join(ADD_DIR, LABEL_DEL_ROUTES),
dest=setup['dut_tmp_dir'])
label_del_dut_path = os.path.join(setup['dut_tmp_dir'],
LABEL_DEL_ROUTES)
# Apply routes with swssconfig
result = duthost.shell(
'docker exec -i swss swssconfig /dev/stdin < {}'.format(
label_del_dut_path),
module_ignore_errors=True)
if result['rc'] != 0:
pytest.fail(
'Failed to apply labelroute configuration file: {}'.format(
result['stderr']))
