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)
