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")
if self.ignore_ttl:
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "ttl")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "chksum")
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")
if self.ignore_ttl:
masked_exp_pkt.set_do_not_care_scapy(scapy.IPv6, "hlim")
masked_exp_pkt.set_do_not_care_scapy(scapy.IPv6, "chksum")
src_port = self.src_ptf_port_list[0]
send_packet(self, src_port, pkt)
dst_port_list = self.dst_ptf_port_list
logging.info("Sending packet from port " + str(src_port) + " to " + ip_dst + " expected ports " + str(dst_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 test_mask__check_masking_conditional_field(self,
scapy_simple_vxlan_packet):
simple_vxlan = scapy_simple_vxlan_packet
simple_vxlan[VXLAN].flags = "G"
masked_simple_vxlan = Mask(simple_vxlan)
masked_simple_vxlan.set_do_not_care_packet(VXLAN,
"gpid") # gpflags, gpid
second_masked_packet = Mask(simple_vxlan)
second_masked_packet.set_do_not_care_packet(VXLAN, "gpflags")
assert (masked_simple_vxlan.mask !=
second_masked_packet.mask), "Masks should not be equal"
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_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 generate_expected_packet(self, inner_pkt):
"""
Generate ip_in_ip packet for verifying.
"""
inner_pkt = inner_pkt.copy()
inner_pkt.ttl = inner_pkt.ttl - 1
pkt = scapy.Ether(dst=self.active_tor_mac, src=self.standby_tor_mac) / \
scapy.IP(src=self.standby_tor_ip, dst=self.active_tor_ip) / inner_pkt['IP']
exp_pkt = Mask(pkt)
exp_pkt.set_do_not_care_scapy(scapy.Ether, 'dst')
exp_pkt.set_do_not_care_scapy(scapy.IP, "ihl")
exp_pkt.set_do_not_care_scapy(scapy.IP, "tos")
exp_pkt.set_do_not_care_scapy(scapy.IP, "len")
exp_pkt.set_do_not_care_scapy(scapy.IP, "id")
exp_pkt.set_do_not_care_scapy(scapy.IP, "flags")
exp_pkt.set_do_not_care_scapy(scapy.IP, "frag")
exp_pkt.set_do_not_care_scapy(scapy.IP, "ttl")
exp_pkt.set_do_not_care_scapy(scapy.IP, "proto")
exp_pkt.set_do_not_care_scapy(scapy.IP, "chksum")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "sport")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "seq")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "ack")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "reserved")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "dataofs")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "window")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "chksum")
exp_pkt.set_do_not_care_scapy(scapy.TCP, "urgptr")
exp_pkt.set_ignore_extra_bytes()
return exp_pkt
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 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 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 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 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 runIntTransitTest(self, pkt, tagged1, tagged2,
ignore_csum=False, switch_id=1, mpls=False):
if IP not in pkt:
self.fail("Packet is not IP")
if UDP not in pkt and TCP not in pkt:
self.fail("Packet must be UDP or TCP for INT tests")
if INT_META_HDR not in pkt:
self.fail("Packet must have INT_META_HDR")
if INT_L45_HEAD not in pkt:
self.fail("Packet must have INT_L45_HEAD")
proto = UDP if UDP in pkt else TCP
# will use runIPv4UnicastTest
dst_mac = HOST2_MAC
ig_port = self.port1
eg_port = self.port2
self.setup_transit(switch_id)
instructions = self.get_ins_from_mask(pkt[INT_META_HDR].inst_mask)
ins_cnt = len(instructions)
assert ins_cnt == pkt[INT_META_HDR].ins_cnt
# Forge expected packet based on pkt's ins_mask
new_metadata, masked_ins_cnt = self.get_int_metadata(
instructions=instructions, switch_id=switch_id,
ig_port=ig_port, eg_port=eg_port)
exp_pkt = pkt.copy()
exp_pkt[INT_L45_HEAD].length += pkt[INT_META_HDR].ins_cnt
exp_pkt[INT_META_HDR].total_hop_cnt += 1
exp_pkt[INT_META_HDR].payload = new_metadata + str(exp_pkt[INT_META_HDR].payload)
exp_pkt[Ether].src = exp_pkt[Ether].dst
exp_pkt[Ether].dst = dst_mac
if not mpls:
exp_pkt[IP].ttl = exp_pkt[IP].ttl - 1
else:
exp_pkt = pkt_add_mpls(exp_pkt, MPLS_LABEL_2, DEFAULT_MPLS_TTL)
if tagged2:
# VLAN if tagged1 will be added by runIPv4UnicastTest
exp_pkt = pkt_add_vlan(exp_pkt, VLAN_ID_2)
if ignore_csum or masked_ins_cnt > 0:
mask_pkt = Mask(exp_pkt)
if ignore_csum:
csum_offset = len(exp_pkt) - len(exp_pkt[IP].payload) \
+ (6 if proto is UDP else 16)
mask_pkt.set_do_not_care(csum_offset * 8, 2 * 8)
if masked_ins_cnt > 0:
offset_metadata = len(exp_pkt) - len(exp_pkt[proto].payload) \
+ len(INT_L45_HEAD()) + len(INT_META_HDR()) \
+ (ins_cnt - masked_ins_cnt) * 4
mask_pkt.set_do_not_care(offset_metadata * 8, masked_ins_cnt * 4 * 8)
exp_pkt = mask_pkt
self.runIPv4UnicastTest(pkt=pkt, next_hop_mac=HOST2_MAC,
tagged1=tagged1, tagged2=tagged2, mpls=mpls,
prefix_len=32, exp_pkt=exp_pkt)
