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