def test_decap_active_tor(build_encapsulated_packet, request, ptfhost,
rand_selected_interface, ptfadapter, tbinfo,
rand_selected_dut, tunnel_traffic_monitor):
@contextlib.contextmanager
def stop_garp(ptfhost):
"""Temporarily stop garp service."""
ptfhost.shell("supervisorctl stop garp_service")
yield
ptfhost.shell("supervisorctl start garp_service")
if is_t0_mocked_dualtor(tbinfo):
request.getfixturevalue('apply_active_state_to_orchagent')
else:
request.getfixturevalue(
'toggle_all_simulator_ports_to_rand_selected_tor')
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,
decrease_ttl=True)
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
with stop_garp(ptfhost):
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, int(ptf_t1_intf.strip("eth")),
encapsulated_packet)
testutils.verify_packet(ptfadapter,
exp_pkt,
exp_ptf_port_index,
timeout=10)
def runArpBroadcastTest(self, tagged_ports, untagged_ports):
zero_mac_addr = ":".join(["00"] * 6)
vlan_id = 10
next_id = vlan_id
mcast_group_id = vlan_id
all_ports = set(tagged_ports + untagged_ports)
arp_pkt = testutils.simple_arp_packet(pktlen=76)
# Account for VLAN header size in total pktlen
vlan_arp_pkt = testutils.simple_arp_packet(vlan_vid=vlan_id, pktlen=80)
for port in tagged_ports:
self.set_ingress_port_vlan(port, True, vlan_id, vlan_id)
for port in untagged_ports:
self.set_ingress_port_vlan(port, False, 0, vlan_id)
self.add_bridging_entry(vlan_id, zero_mac_addr, zero_mac_addr, next_id)
self.add_next_multicast(next_id, mcast_group_id)
self.add_mcast_group(mcast_group_id, all_ports)
for port in untagged_ports:
self.set_egress_vlan_pop(port, vlan_id)
for inport in all_ports:
pkt_to_send = vlan_arp_pkt if inport in tagged_ports else arp_pkt
testutils.send_packet(self, inport, str(pkt_to_send))
# Packet should be received on all ports expect the ingress one.
verify_tagged_ports = set(tagged_ports)
verify_tagged_ports.discard(inport)
for tport in verify_tagged_ports:
testutils.verify_packet(self, vlan_arp_pkt, tport)
verify_untagged_ports = set(untagged_ports)
verify_untagged_ports.discard(inport)
for uport in verify_untagged_ports:
testutils.verify_packet(self, arp_pkt, uport)
testutils.verify_no_other_packets(self)
def mux_sim_check_downstream(active_tor, standby_tor, ptfadapter,
active_tor_ping_tgt_ip, standby_tor_ping_tgt_ip,
active_tor_exp_pkt, standby_tor_exp_pkt,
ptf_port_index, tor_mux_intf):
failed = False
reason = ''
host = None
ping_cmd = 'ping -I {} {} -c 1 -W 1; true'
# Clear ARP tables to start in consistent state
active_tor.shell("ip neigh flush all")
standby_tor.shell("ip neigh flush all")
# Ping from both ToRs, expect only message from active ToR to reach PTF
active_tor.shell(ping_cmd.format(tor_mux_intf, active_tor_ping_tgt_ip))
try:
testutils.verify_packet(ptfadapter, active_tor_exp_pkt, ptf_port_index)
except AssertionError:
failed = True
reason = 'Packet from active ToR {} not received'.format(active_tor)
host = active_tor.hostname
return failed, reason, host
standby_tor.shell(ping_cmd.format(tor_mux_intf, standby_tor_ping_tgt_ip))
try:
testutils.verify_no_packet(ptfadapter, standby_tor_exp_pkt,
ptf_port_index)
except AssertionError:
failed = True
reason = 'Packet from standby ToR {} received'.format(standby_tor)
host = standby_tor.hostname
return failed, reason, host
def send_and_verify_traffic(ptfadapter,
pkt,
exp_pkt,
src_port,
dst_port,
pkt_action=ACTION_FORWARD):
"""
Send traffic and verify that traffic was received
Args:
ptfadapter: PTF adapter
pkt: Packet that should be sent
exp_pkt: Expected packet
src_port: Source port
dst_port: Destination port
pkt_action: Packet action (forward or drop)
"""
ptfadapter.dataplane.flush()
logger.info("Send packet from port {} to port {}".format(
src_port, dst_port))
testutils.send(ptfadapter, src_port, pkt)
if pkt_action == ACTION_FORWARD:
testutils.verify_packet(ptfadapter, exp_pkt, dst_port)
elif pkt_action == ACTION_DROP:
testutils.verify_no_packet(ptfadapter, exp_pkt, dst_port)
def verify_ack_received(self):
dhcp_ack = self.create_dhcp_ack_relayed_packet()
masked_ack = Mask(dhcp_ack)
masked_ack.set_do_not_care_scapy(scapy.IP, "version")
masked_ack.set_do_not_care_scapy(scapy.IP, "ihl")
masked_ack.set_do_not_care_scapy(scapy.IP, "tos")
masked_ack.set_do_not_care_scapy(scapy.IP, "len")
masked_ack.set_do_not_care_scapy(scapy.IP, "id")
masked_ack.set_do_not_care_scapy(scapy.IP, "flags")
masked_ack.set_do_not_care_scapy(scapy.IP, "frag")
masked_ack.set_do_not_care_scapy(scapy.IP, "ttl")
masked_ack.set_do_not_care_scapy(scapy.IP, "proto")
masked_ack.set_do_not_care_scapy(scapy.IP, "chksum")
masked_ack.set_do_not_care_scapy(scapy.IP, "options")
masked_ack.set_do_not_care_scapy(scapy.UDP, "len")
masked_ack.set_do_not_care_scapy(scapy.UDP, "chksum")
masked_ack.set_do_not_care_scapy(scapy.BOOTP, "sname")
masked_ack.set_do_not_care_scapy(scapy.BOOTP, "file")
masked_ack.set_do_not_care_scapy(scapy.DHCP, "lease_time")
# NOTE: verify_packet() will fail for us via an assert, so no need to check a return value here
testutils.verify_packet(self, masked_ack, self.client_port_index)
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 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 verify_packet(self, exp_pkt, port):
port_list = []
port_list.append(port)
if self.generate_tv:
tvutils.add_traffic_expectation(self.tc, port_list, exp_pkt)
else:
testutils.verify_packet(self, exp_pkt, port)
def generate_and_verify_traffic(duthost1,
duthost2,
ptfadapter,
ptfhost,
src_port,
dst_ip,
router_mac,
get_routes,
collect,
down_link_on_dut=None,
pkt_action=ACTION_FORWARD):
"""
Generate traffic, send and verify it
Args:
duthost1: DUT host object
duthost2: DUT host object
ptfadapter: PTF adapter
ptfhost: PTF host object
src_port: Source port from which pkt will be sent
dst_ip: Destination ip address
get_routes: Dict with routes for each DUT
collect: Fixture which collects main info about link connection
down_link_on_dut: Name of DUT on which link is down
pkt_action: Action to verify, forward or drop
"""
router1_mac = duthost1.facts["router_mac"]
router2_mac = duthost2.facts["router_mac"]
dst_ports = get_dst_port(duthost1, duthost2, get_routes, dst_ip, collect)
src_port = get_port_number(ptfhost, src_port)
pkt = craft_pkt(ptfadapter, router_mac, src_port, dst_ip)
expected_src_mac = router1_mac if dst_ports == collect[
duthost1.hostname]['vm_link_on_ptf'] else router2_mac
exp_pkt = pkt.copy()
if down_link_on_dut:
exp_ttl = predict_exp_ttl(duthost1, duthost2, dst_ip, down_link_on_dut)
exp_pkt[packet.IP].ttl = exp_ttl
exp_pkt[packet.Ether].src = unicode(expected_src_mac)
exp_pkt = mask.Mask(exp_pkt)
exp_pkt.set_do_not_care_scapy(packet.Ether, "dst")
exp_pkt.set_do_not_care_scapy(packet.IP, "id")
exp_pkt.set_do_not_care_scapy(packet.IP, "chksum")
exp_pkt.set_do_not_care_scapy(packet.TCP, "chksum")
if not down_link_on_dut:
exp_pkt.set_do_not_care_scapy(packet.IP, "ttl")
ptfadapter.dataplane.flush()
time.sleep(2)
logger.info(
"Sending pkt from port {} to dst_ip = {}, expected dst_port = {}".
format(src_port, dst_ip, dst_ports))
logger.info(pkt.sprintf("%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%"))
testutils.send(ptfadapter, src_port, pkt)
if pkt_action == ACTION_FORWARD:
testutils.verify_packet(ptfadapter, exp_pkt, dst_ports)
elif pkt_action == ACTION_DROP:
testutils.verify_no_packet(ptfadapter, exp_pkt, dst_ports)
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):
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):
pkt = "ab" * 20
testutils.send_packet(self, (0, 1), str(pkt))
print "packet sent"
testutils.verify_packet(self, pkt, (1, 1))
# We remove a port to test port_remove, but in order to execute
# subsequent tests, we need to make sure we re-add the port
# afterwards. In order to re-add the port, we need the interface name,
# which is what this method is for. This is a little hacky but fine for
# testing. In practice, you would not be removing ports which are part
# of the original ptf config.
def find_ifname(device_number, port_number):
for port_id, ifname in config["port_map"].items():
if (device_number, port_number) == port_id:
return ifname
ifname = find_ifname(1, 1)
self.assertTrue(self.dataplane.port_remove(1, 1))
testutils.send_packet(self, (0, 1), str(pkt))
print "packet sent"
testutils.verify_no_other_packets(self, device_number=1)
self.dataplane.port_add(ifname, 1, 1)
testutils.send_packet(self, (0, 1), str(pkt))
print "packet sent"
testutils.verify_packet(self, pkt, (1, 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 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 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 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 _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 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 runTest(self):
pktlen = 400
pkt = testutils.simple_ipv6ip_packet(pktlen=pktlen)
self.assertEqual(len(pkt), pktlen)
testutils.send_packet(self, (0, 1), pkt)
print("packet sent")
testutils.verify_packet(self, pkt, (1, 1))
testutils.verify_no_other_packets(self, 1)
def runTest(self):
self.setup_int()
dport = 5060
# int_type=hop-by-hop
int_shim = INT_L45_HEAD(int_type=1, length=4)
# ins_cnt: 5 = switch id + ports + q occupancy + ig port + eg port)
# max_hop_count: 3
# total_hop_count: 0
# instruction_mask_0003: 0xd = switch id (0), ports (1), q occupancy (3)
# instruction_mask_0407: 0xc = ig timestamp (4), eg timestamp (5)
int_header = "\x00\x05\x03\x00\xdc\x00\x00\x00"
# IP proto (UDP), UDP dport (4096)
int_tail = INT_L45_TAIL(next_proto=17, proto_param=dport)
payload = "\xab" * 128
inner_udp = UDP(sport=5061, dport=dport, chksum=0)
# IP tos is 0x04 to enable INT
pkt = Ether(src=self.DMAC_2, dst=self.SWITCH_MAC_2) / \
IP(tos=0x04, src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4) / \
inner_udp / \
int_shim / int_header / int_tail / \
payload
exp_int_shim = INT_L45_HEAD(int_type=1, length=9)
# total_hop_count: 1
exp_int_header = "\x00\x05\x03\x01\xdc\x00\x00\x00"
# switch id: 1
exp_int_metadata = "\x00\x00\x00\x01"
# ig port: port2, eg port: port2
exp_int_metadata += stringify(self.port2, 2) + stringify(self.port1, 2)
# q id: 0, q occupancy: ?
exp_int_metadata += "\x00\x00\x00\x00"
# ig timestamp: ?
# eg timestamp: ?
exp_int_metadata += "\x00\x00\x00\x00" * 2
exp_int = exp_int_shim / exp_int_header / exp_int_metadata / int_tail
exp_pkt = Ether(src=self.SWITCH_MAC_1, dst=self.DMAC_1) / \
MPLS(label=self.mpls_label, cos=0, s=1, ttl=64) / \
IP(tos=0, id=0x1513, flags=0, frag=0,
src=self.S1U_SGW_IPV4, dst=self.S1U_ENB_IPV4) / \
UDP(sport=2152, dport=2152, chksum=0) / \
make_gtp(20 + len(inner_udp) + len(exp_int) + len(payload), 1) / \
IP(tos=0x04, src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4, ttl=64) / \
inner_udp / \
exp_int / \
payload
# We mask off the timestamps as well as the queue occupancy
exp_pkt = Mask(exp_pkt)
offset_metadata = 14 + 4 + 20 + 8 + 8 + 20 + 8 + 4 + 8
exp_pkt.set_do_not_care((offset_metadata + 9) * 8, 11 * 8)
testutils.send_packet(self, self.port2, str(pkt))
testutils.verify_packet(self, exp_pkt, self.port1)
def runTest(self):
pkt = genNdpNsPkt(HOST1_MAC, HOST1_IPV6, SWITCH1_IPV6)
exp_pkt = genNdpNaPkt(SWITCH1_MAC, IPV6_MCAST_MAC_1, SWITCH1_IPV6,
HOST1_IPV6)
self.add_ndp_reply_entry(SWITCH1_IPV6, SWITCH1_MAC)
testutils.send_packet(self, self.port1, str(pkt))
testutils.verify_packet(self, exp_pkt, self.port1)
def runTest(self):
pkt = testutils.simple_tcp_packet(pktlen=100)
try:
testutils.send_packet(self, (0, 1), pkt)
except Exception as e:
print(e)
testutils.verify_packet(self, pkt, (1, 1))
def runTest(self):
pktlen = 70
pkt = testutils.simple_ipv4ip_packet(pktlen=pktlen)
pkt2 = testutils.simple_ipv4ip_packet(pktlen=pktlen,
inner_frame=pkt["IP"])
testutils.send_packet(self, (0, 1), pkt2)
print("packet sent")
testutils.verify_packet(self, pkt2, (1, 1))
testutils.verify_no_other_packets(self, 1)
def verify_packet_out(self, pkt, out_port):
port_hex = stringify(out_port, 2)
packet_out = p4runtime_pb2.PacketOut()
packet_out.payload = str(pkt)
egress_physical_port = packet_out.metadata.add()
egress_physical_port.metadata_id = 1
egress_physical_port.value = port_hex
self.send_packet_out(packet_out)
testutils.verify_packet(self, pkt, out_port)
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 runPacketOutTest(self, pkt):
for port in [self.port1, self.port2]:
port_hex = stringify(port, 2)
packet_out = p4runtime_pb2.PacketOut()
packet_out.payload = str(pkt)
egress_physical_port = packet_out.metadata.add()
egress_physical_port.metadata_id = 1
egress_physical_port.value = port_hex
self.send_packet_out(packet_out)
testutils.verify_packet(self, pkt, port)
testutils.verify_no_other_packets(self)
def runTest(self):
target = gc.Target(device_id=0, pipe_id=0xffff)
# Get bfrt_info
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)
# Add bridge_md to ig_intr_md
table_bridge_md_ctl = bfrt_info.table_get(
"SwitchIngress.bridge_md_ctrl")
action_data = table_bridge_md_ctl.make_data(
[
gc.DataTuple(name="dst_mac_addr_low", val=0xffeeddcc),
gc.DataTuple(name="src_mac_addr_low", val=0x11223344),
],
action_name="SwitchIngress.bridge_add_example_hdr")
table_bridge_md_ctl.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:22:22:22:22:22',
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 = testutils.simple_tcp_packet(eth_dst='00:00:ff:ee:dd:cc',
eth_src='00:00:11:22:33:44',
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)
testutils.send_packet(self, swports[0], ipkt)
testutils.verify_packet(self, epkt, swports[1])
finally:
table_output_port.default_entry_reset(target)
table_bridge_md_ctl.default_entry_reset(target)
def verify_relayed_reply(self):
# Create a packet resembling a DHCPv6 REPLY packet
reply_packet = self.create_dhcp_reply_packet()
# Mask off fields we don't care about matching
masked_packet = Mask(reply_packet)
masked_packet.set_do_not_care_scapy(IPv6, "fl")
masked_packet.set_do_not_care_scapy(packet.UDP, "chksum")
masked_packet.set_do_not_care_scapy(packet.UDP, "len")
# NOTE: verify_packet() will fail for us via an assert, so no need to check a return value here
testutils.verify_packet(self, masked_packet, self.client_port_index)
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.sntpat",
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=0x1)
],
)
table_translate.default_entry_set(target=target, data=action_data)
try:
ipkt = testutils.simple_tcp_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,
tcp_sport=0x1234,
tcp_dport=0xabcd,
with_tcp_chksum=True)
epkt = testutils.simple_tcp_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,
tcp_sport=0x4321,
tcp_dport=0xabcd,
with_tcp_chksum=True)
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 runTest(self):
pktlen = 1000
udp = testutils.simple_udp_packet()
ipv6 = testutils.simple_ipv6ip_packet(inner_frame=udp['UDP'])
gre = testutils.simple_grev6_packet(pktlen=pktlen,
inner_frame=ipv6["IPv6"])
self.assertEqual(gre['GRE'].proto, 0x86DD)
testutils.send_packet(self, (0, 1), gre)
print("packet sent")
testutils.verify_packet(self, gre, (1, 1))
testutils.verify_no_other_packets(self, 1)
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 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)
ipv4_match_regular = bfrt_info.table_get("SwitchIngress.ipv4_match_regular")
ipv4_match_regular.info.key_field_annotation_add('hdr.ethernet.dst_addr',
'mac')
ipv4_match_regular.info.key_field_annotation_add('hdr.ethernet.src_addr',
'mac')
ipv4_match_regular.info.key_field_annotation_add('hdr.ipv4.dst_addr',
'ipv4')
ipv4_match_regular.info.key_field_annotation_add('hdr.ipv4.src_addr',
'ipv4')
key_data_regular = ipv4_match_regular.make_key([
gc.KeyTuple(name='hdr.ethernet.dst_addr',
value='11:11:11:11:11:11'),
gc.KeyTuple(name='hdr.ethernet.src_addr',
value='22:22:22:22:22:22'),
gc.KeyTuple(name='hdr.ipv4.dst_addr',
value='100.99.98.97'),
gc.KeyTuple(name='hdr.ipv4.src_addr',
value='1.2.3.4'),
])
action_data_regular = ipv4_match_regular.make_data(
[gc.DataTuple(name='port_id', val=swports[3])], 'SwitchIngress.set_output_port'
)
ipv4_match_regular.entry_add(
target,
[key_data_regular],
[action_data_regular])
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[3])
finally:
ipv4_match_regular.default_entry_reset(target)
ipv4_match_regular.entry_del(target, [key_data_regular])
def runTest(self):
pkt = "ab" * 20
testutils.send_packet(self, (0, 1), str(pkt))
print "packet sent"
testutils.verify_packet(self, pkt, (1, 1))
