def check_packet_transmission(self, pkt_types, layer_configs=None):
time.sleep(1)
for pkt_type in pkt_types.keys():
pkt_names = pkt_types[pkt_type]
pkt = Packet(pkt_type=pkt_type)
if layer_configs:
for layer in layer_configs.keys():
pkt.config_layer(layer, layer_configs[layer])
inst = sniff_packets(self.tester_iface, count=1, timeout=8)
pkt.send_pkt(tx_port=self.tester_iface)
out = self.dut.get_session_output(timeout=2)
time.sleep(1)
load_sniff_packets(inst)
if self.printFlag: # debug output
print out
for pkt_layer_name in pkt_names:
if self.printFlag:# debug output
print pkt_layer_name
if pkt_layer_name not in out:
print utils.RED("Fail to detect %s" % pkt_layer_name)
if not self.printFlag:
raise VerifyFailure("Failed to detect %s" % pkt_layer_name)
else:
print utils.GREEN("Detected %s successfully" % pkt_type)
time.sleep(1)
def get_tcpdump_package(self):
pkts = load_sniff_packets(self.inst)
dsts = []
for packet in pkts:
dst = packet.strip_element_layer2("dst")
dsts.append(dst)
return dsts
def test_pvid_vf_tx(self):
"""
Add port based vlan on vf device and check vlan tx work
"""
random_vlan = random.randint(1, MAX_VLAN)
self.dut.send_expect(
"ip link set %s vf 0 vlan %d" % (self.host_intf0, random_vlan), "# ")
out = self.dut.send_expect("ip link show %s" % self.host_intf0, "# ")
self.verify("vlan %d" %
random_vlan in out, "Failed to add pvid on VF0")
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
self.vm0_testpmd.execute_cmd('set fwd mac')
self.vm0_testpmd.execute_cmd('start')
pkt = Packet(pkt_type='UDP')
pkt.config_layer('ether', {'dst': self.vf1_mac})
inst = sniff_packets(self.tester_intf0, timeout=5)
pkt.send_pkt(tx_port=self.tester_intf1)
pkts = load_sniff_packets(inst)
self.verify(len(pkts), "Not receive expected packet")
self.vm0_testpmd.quit()
# disable pvid
self.dut.send_expect(
"ip link set %s vf 0 vlan 0" % (self.host_intf0), "# ")
def get_tcpdump_package(self):
pkts = load_sniff_packets(self.inst)
vlans = []
for packet in pkts:
vlan = packet.strip_element_vlan("vlan")
vlans.append(vlan)
return vlans
def strip_vlan(self, inst):
"""
Load sniff packets, strip and return vlan id from dump message
"""
pkts = load_sniff_packets(inst)
vlans = []
for pkt in pkts:
vlan = pkt.strip_element_vlan("vlan")
vlans.append(vlan)
return vlans
def strip_mac(self, inst, element="src"):
"""
Load sniff packets, strip and return mac address from dump message
"""
pkts = load_sniff_packets(inst)
macs = []
for pkt in pkts:
mac = pkt.strip_element_layer2(element)
macs.append(mac)
return macs
def functional_check_ipv4(self, pkt_sizes, burst=1, flag=None):
"""
Perform functional fragmentation checks.
"""
for size in pkt_sizes[::burst]:
# simulate to set TG properties
if flag == 'frag':
# do fragment, each packet max length 1518 - 18 - 20 = 1480
expPkts = (size - HEADER_SIZE['eth'] - HEADER_SIZE['ip']) / 1480
if (size - HEADER_SIZE['eth'] - HEADER_SIZE['ip']) % 1480:
expPkts += 1
val = 0
elif flag == 'nofrag':
expPkts = 0
val = 2
else:
expPkts = 1
val = 2
inst = sniff_packets(intf=self.rxItf, timeout=5)
# send packet
for times in range(burst):
pkt_size = pkt_sizes[pkt_sizes.index(size) + times]
pkt = Packet(pkt_type='UDP', pkt_len=pkt_size)
pkt.config_layer('ether', {'dst': self.dmac})
pkt.config_layer('ipv4', {'dst': '100.10.0.1', 'src': '1.2.3.4', 'flags': val})
pkt.send_pkt(tx_port=self.txItf)
# verify normal packet just by number, verify fragment packet by all elements
pkts = load_sniff_packets(inst)
self.verify(len(pkts) == expPkts, "Failed on forward packet size " + str(size))
if flag == 'frag':
idx = 1
for pkt in pkts:
# packet index should be same
pkt_id = pkt.strip_element_layer3("id")
if idx == 1:
prev_idx = pkt_id
self.verify(prev_idx == pkt_id, "Fragmented packets index not match")
prev_idx = pkt_id
# last flags should be 0
flags = pkt.strip_element_layer3("flags")
if idx == expPkts:
self.verify(flags == 0, "Fragmented last packet flags not match")
else:
self.verify(flags == 1, "Fragmented packets flags not match")
# fragment offset should be correct
frag = pkt.strip_element_layer3("frag")
self.verify((frag == ((idx - 1) * 185)), "Fragment packet frag not match")
idx += 1
def tx_and_check(self, tx_vlan=1):
inst = sniff_packets(self.tester_intf0, timeout=5)
self.vm0_testpmd.execute_cmd('set burst 1')
self.vm0_testpmd.execute_cmd('start tx_first')
self.vm0_testpmd.execute_cmd('stop')
# strip sniffered vlans
pkts = load_sniff_packets(inst)
vlans = []
for pkt in pkts:
vlan = pkt.strip_element_vlan("vlan")
vlans.append(vlan)
self.verify(tx_vlan in vlans, "Tx packet with vlan not received!!!")
def functional_check_ipv6(self, pkt_sizes, burst=1, flag=None, funtion=None):
"""
Perform functional fragmentation checks.
"""
for size in pkt_sizes[::burst]:
# simulate to set TG properties
if flag == 'frag':
# each packet max len: 1518 - 18 (eth) - 40 (ipv6) - 8 (ipv6 ext hdr) = 1452
expPkts = (size - HEADER_SIZE['eth'] - HEADER_SIZE['ipv6']) / 1452
if (size - HEADER_SIZE['eth'] - HEADER_SIZE['ipv6']) % 1452:
expPkts += 1
val = 0
else:
expPkts = 1
val = 2
inst = sniff_packets(intf=self.rxItf, timeout=5)
# send packet
for times in range(burst):
pkt_size = pkt_sizes[pkt_sizes.index(size) + times]
pkt = Packet(pkt_type='IPv6_UDP', pkt_len=pkt_size)
pkt.config_layer('ether', {'dst': self.dmac})
pkt.config_layer('ipv6', {'dst': '101:101:101:101:101:101:101:101', 'src': 'ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80'})
pkt.send_pkt(tx_port=self.txItf)
# verify normal packet just by number, verify fragment packet by all elements
pkts = load_sniff_packets(inst)
self.verify(len(pkts) == expPkts, "Failed on forward packet size " + str(size))
if flag == 'frag':
idx = 1
for pkt in pkts:
# packet index should be same
pkt_id = pkt.strip_element_layer4("id")
if idx == 1:
prev_idx = pkt_id
self.verify(prev_idx == pkt_id, "Fragmented packets index not match")
prev_idx = pkt_id
# last flags should be 0
flags = pkt.strip_element_layer4("m")
if idx == expPkts:
self.verify(flags == 0, "Fragmented last packet flags not match")
else:
self.verify(flags == 1, "Fragmented packets flags not match")
# fragment offset should be correct
frag = pkt.strip_element_layer4("offset")
self.verify((frag == int((idx - 1) * 181.5)), "Fragment packet frag not match")
idx += 1
def scatter_pktgen_send_packet(self, pktsize):
"""
Functional test for scatter packets.
"""
dmac = self.dut.get_mac_address(self.port)
inst = sniff_packets(self.intf)
pkt = Packet(pkt_type="IP_RAW", pkt_len=pktsize)
pkt.config_layer('ether', {'dst': dmac})
pkt.send_pkt(tx_port=self.intf)
sniff_pkts = load_sniff_packets(inst)
res = ""
if len(sniff_pkts):
res = strip_pktload(sniff_pkts[0], layer="L4")
return res
def check_packets_transfer(self, tx_port, rx_port, tgen_input, pkt_cnt=1):
'''
check packets transmission status
'''
# check forwarded mac has been changed
rev_port = self.tester.get_local_port(rx_port)
send_port = self.tester.get_local_port(tx_port)
dst_mac = self.dut.get_mac_address(rx_port)
rx_intf = self.tester.get_interface(rev_port)
tx_intf = self.tester.get_interface(send_port)
# send and sniff packet
rx_inst = sniff_packets(rx_intf, timeout=5)
self.send_pcap_pkt_by_scapy(self.tester, tgen_input[0][2], tx_intf)
pkts = load_sniff_packets(rx_inst)
self.verify(len(pkts) == pkt_cnt, "Packet not forwarded as expected")
return
def test_mac_address(self):
"""
Test ethtool app mac function
"""
valid_mac = "00:10:00:00:00:00"
self.dut.send_expect(self.cmd, "EthApp>", 60)
for index in range(len(self.ports)):
port = self.ports[index]
mac = self.dut.ports_info[port]['mac']
dump_mac = self.strip_mac(index)
self.verify(mac == dump_mac, "Userspace tool failed to dump mac")
self.dut.send_expect("macaddr %d %s" % (port, valid_mac),
"EthApp>")
dump_mac = self.strip_mac(index)
self.verify(dump_mac == valid_mac,
"Userspace tool failed to set mac")
# check forwarded mac has been changed
pkt = Packet()
tester_port = self.tester.get_local_port(port)
intf = self.tester.get_interface(tester_port)
# send and sniff packet
inst = sniff_packets(intf, timeout=5)
pkt.send_pkt(tx_port=intf)
pkts = load_sniff_packets(inst)
self.verify(len(pkts) == 1, "Packet not forwarded as expected")
src_mac = pkts[0].strip_layer_element("layer2", "src")
self.verify(src_mac == valid_mac,
"Forwarded packet not match default mac")
# check multicase will not be valid mac
invalid_mac = "01:00:00:00:00:00"
out = self.dut.send_expect("validate %s" % invalid_mac, "EthApp>")
self.verify("not unicast" in out,
"Failed to detect incorrect unicast mac")
invalid_mac = "00:00:00:00:00:00"
out = self.dut.send_expect("validate %s" % invalid_mac, "EthApp>")
self.verify("not unicast" in out,
"Failed to detect incorrect unicast mac")
out = self.dut.send_expect("validate %s" % valid_mac, "EthApp>")
self.verify("is unicast" in out,
"Failed to detect correct unicast mac")
self.dut.send_expect("quit", "# ")
def test_etag_insertion(self):
'''
When E-tag insertion enable in VF0
'''
host_cmds = [['port config 0 l2-tunnel E-tag enable'],
['E-tag set insertion on port-tag-id 1000 port 0 vf 0'],
['set fwd mac'], ['set verbose 1'], ['start']]
guest_cmds = [['set fwd mac'], ['set verbose 1'], ['start']]
self.preset_test_enviroment()
self.execute_host_testpmd_cmd(host_cmds)
self.execute_guest_testpmd_cmd(guest_cmds)
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
config_layers = {'ether': {'src': self.src_mac}}
pkt_types = {'IP_RAW': {'layer_configs': config_layers}}
intf = self.src_intf
inst = sniff_packets(intf)
self.check_packet_transmission(pkt_types)
time.sleep(1)
pkts = load_sniff_packets(inst)
self.host_testpmd.execute_cmd(
'E-tag set insertion off port-tag-id 1000 port 0 vf 0')
# load sniff pcap file, check received packet's content
packetContentFile = "/tmp/packetContent.log"
pcap_file = "/tmp/sniff_%s.pcap" % intf
fp = open(packetContentFile, 'w')
backup_out = sys.stdout
sys.stdout = fp
pkts = rdpcap(pcap_file)
pkts.show()
fp.close()
sys.stdout = backup_out
fp = open(packetContentFile, 'r')
out = fp.read()
fp.close()
if self.printFlag: # debug output
print out
self.verify("Dot1BR" in out,
"tester %s hasn't receiver etag packet" % intf)
def send_packet(self, txPort, rxPort, nic, pktSize=64, received=True):
"""
Send packages according to parameters.
"""
rxitf = self.tester.get_interface(self.tester.get_local_port(rxPort))
txitf = self.tester.get_interface(self.tester.get_local_port(txPort))
dmac = self.dut.get_mac_address(txPort)
pkt = Packet(pkt_type="UDP", pkt_len=pktSize)
inst = sniff_packets(rxitf)
pkt.config_layer('ether', {'dst': dmac})
pkt.send_pkt(tx_port=txitf)
sniff_pkts = load_sniff_packets(inst)
if received:
res = strip_pktload(sniff_pkts[0], layer="L4")
self.verify("58 58 58 58 58 58 58 58" in res,
"receive queue not work as expected")
else:
self.verify(
len(sniff_pkts) == 0, "stop queue not work as expected")
def checksum_validate(self, packets_sent, packets_expected):
"""
Validate the checksum.
"""
tx_interface = self.tester.get_interface(
self.tester.get_local_port(self.dut_ports[0]))
rx_interface = self.tester.get_interface(
self.tester.get_local_port(self.dut_ports[0]))
sniff_src = self.dut.get_mac_address(self.dut_ports[0])
checksum_pattern = re.compile("chksum.*=.*(0x[0-9a-z]+)")
chksum = dict()
result = dict()
self.tester.send_expect("scapy", ">>> ")
for packet_type in packets_expected.keys():
self.tester.send_expect("p = %s" % packets_expected[packet_type],
">>>")
out = self.tester.send_expect("p.show2()", ">>>")
chksums = checksum_pattern.findall(out)
chksum[packet_type] = chksums
self.tester.send_expect("exit()", "#")
inst = sniff_packets(intf=rx_interface,
count=len(packets_sent),
filters=[{
'layer': 'ether',
'config': {
'src': sniff_src
}
}])
for packet_type in packets_sent.keys():
self.tester.scapy_append('sendp([%s], iface="%s")' %
(packets_sent[packet_type], tx_interface))
self.tester.scapy_execute()
p = load_sniff_packets(inst)
nr_packets = len(p)
reslist = [
p[i].pktgen.pkt.sprintf(
"%IP.chksum%;%TCP.chksum%;%UDP.chksum%;%SCTP.chksum%")
for i in range(nr_packets)
]
out = string.join(reslist, ",")
packets_received = out.split(',')
self.verify(
len(packets_sent) == len(packets_received),
"Unexpected Packets Drop")
for packet_received in packets_received:
ip_checksum, tcp_checksum, udp_checksum, sctp_checksum = packet_received.split(
';')
packet_type = ''
l4_checksum = ''
if tcp_checksum != '??':
packet_type = 'TCP'
l4_checksum = tcp_checksum
elif udp_checksum != '??':
packet_type = 'UDP'
l4_checksum = udp_checksum
elif sctp_checksum != '??':
packet_type = 'SCTP'
l4_checksum = sctp_checksum
if ip_checksum != '??':
packet_type = 'IP/' + packet_type
if chksum[packet_type] != [ip_checksum, l4_checksum]:
result[packet_type] = packet_type + " checksum error"
else:
packet_type = 'IPv6/' + packet_type
if chksum[packet_type] != [l4_checksum]:
result[packet_type] = packet_type + " checksum error"
return result
