[dts] [PATCH] Support IP reassembly
Liu, Yong
yong.liu at intel.com
Mon Jun 1 11:15:14 CEST 2015
Thanks, applied in 1.1 branch.
> -----Original Message-----
> From: dts [mailto:dts-bounces at dpdk.org] On Behalf Of Xiaonan Zhang
> Sent: Thursday, May 28, 2015 10:01 AM
> To: dts at dpdk.org
> Subject: [dts] [PATCH] Support IP reassembly
>
> From: Zhangxiaonan <xiaonanx.zhang at intel.com>
>
> Add IPV4 reassembly test case and test plan
>
> Signed-off-by: TangHaifeng <haifengx.tang at intel.com>
> ---
> test_plans/ipv4_reassembly_test_plan.rst | 233 ++++++++++++
> tests/TestSuite_ipv4_reassembly.py | 579
> ++++++++++++++++++++++++++++++
> 2 files changed, 812 insertions(+), 0 deletions(-)
> create mode 100644 test_plans/ipv4_reassembly_test_plan.rst
> create mode 100644 tests/TestSuite_ipv4_reassembly.py
>
> diff --git a/test_plans/ipv4_reassembly_test_plan.rst
> b/test_plans/ipv4_reassembly_test_plan.rst
> new file mode 100644
> index 0000000..91ba792
> --- /dev/null
> +++ b/test_plans/ipv4_reassembly_test_plan.rst
> @@ -0,0 +1,233 @@
> +.. Copyright (c) <2013>, Intel Corporation
> + All rights reserved.
> +
> + Redistribution and use in source and binary forms, with or without
> + modification, are permitted provided that the following conditions
> + are met:
> +
> + - Redistributions of source code must retain the above copyright
> + notice, this list of conditions and the following disclaimer.
> +
> + - Redistributions in binary form must reproduce the above copyright
> + notice, this list of conditions and the following disclaimer in
> + the documentation and/or other materials provided with the
> + distribution.
> +
> + - Neither the name of Intel Corporation nor the names of its
> + contributors may be used to endorse or promote products derived
> + from this software without specific prior written permission.
> +
> + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
> + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
> + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
> + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
> + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
> + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
> + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
> + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
> + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
> + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
> + OF THE POSSIBILITY OF SUCH DAMAGE.
> +
> +
> +
> +=============
> +IP Reassembly
> +=============
> +
> +This document provides a test plan for benchmarking of the IP Reassembly
> +sample application. This is a simple example app featuring packet
> processing
> +using Intel® Data Plane Development Kit (Intel® DPDK) that show-cases the
> use
> +of IP fragmented packets reassembly.
> +
> +
> +
> +Prerequisites
> +-------------
> +
> +Support igb_uio and vfio driver, if used vfio, kernel need 3.6+ and
> enable vt-d in bios.
> +When used vfio , used "modprobe vfio" and "modprobe vfio-pci" insmod
> vfiod driver, then used
> +"./tools/dpdk_nic_bind.py --bind=vfio-pci device_bus_id" to bind vfio
> driver to test driver.
> +
> +1x Intel® 82599 (Niantic) NICs (1x 10GbE full duplex optical ports per
> NIC)
> +plugged into the available PCIe Gen2 8-lane slots.
> +
> +
> +Test Case: Send 1K packets, 4 fragments each and 1K maxflows
> +============================================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=10s
> +
> +Sends 1K packets split in 4 fragments each with a ``maxflows`` of 1K.
> +
> +It expects:
> +
> + - 4K IP packets to be sent to the DUT.
> + - 1K TCP packets being forwarded back to the TESTER.
> + - 1K packets with a valid TCP checksum.
> +
> +
> +Test Case: Send 2K packets, 4 fragments each and 1K maxflows
> +============================================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=10s
> +
> +Sends 2K packets split in 4 fragments each with a ``maxflows`` of 1K.
> +
> +It expects:
> +
> + - 8K IP packets to be sent to the DUT.
> + - 1K TCP packets being forwarded back to the TESTER.
> + - 1K packets with a valid TCP checksum.
> +
> +
> +Test Case: Send 4K packets, 7 fragments each and 4K maxflows
> +============================================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=4096 --flowttl=10s
> +
> +Modifies the sample app source code to enable up to 7 fragments per
> packet.
> +Sends 4K packets split in 7 fragments each with a ``maxflows`` of 4K.
> +
> +It expects:
> +
> + - 28K IP packets to be sent to the DUT.
> + - 4K TCP packets being forwarded back to the TESTER.
> + - 4K packets with a valid TCP checksum.
> +
> +
> +Test Case: Send +1K packets and ttl 3s; wait +ttl; send 1K packets
> +==================================================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=3s
> +
> +Sends 1100 packets split in 4 fragments each.
> +
> +It expects:
> +
> + - 4400 IP packets to be sent to the DUT.
> + - 1K TCP packets being forwarded back to the TESTER.
> + - 1K packets with a valid TCP checksum.
> +
> +
> +Then waits until the ``flowttl`` timeout and sends 1K packets.
> +
> +It expects:
> +
> + - 4K IP packets to be sent to the DUT.
> + - 1K TCP packets being forwarded back to the TESTER.
> + - 1K packets with a valid TCP checksum.
> +
> +
> +Test Case: Send more packets than maxflows; only maxflows packets are
> forwarded back
> +=========================================================================
> ===========
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1023 --flowttl=5s
> +
> +Sends 1K packets with ``maxflows`` equal to 1023.
> +
> +It expects:
> +
> + - 4092 IP packets to be sent to the DUT.
> + - 1023 TCP packets being forwarded back to the TESTER.
> + - 1023 packets with a valid TCP checksum.
> +
> +Then sends 1023 packets.
> +
> +It expects:
> +
> + - 4092 IP packets to be sent to the DUT.
> + - 1023 TCP packets being forwarded back to the TESTER.
> + - 1023 packets with a valid TCP checksum.
> +
> +Finally waits until the ``flowttl`` timeout and re-send 1K packets.
> +
> +It expects:
> +
> + - 4092 IP packets to be sent to the DUT.
> + - 1023 TCP packets being forwarded back to the TESTER.
> + - 1023 packets with a valid TCP checksum.
> +
> +
> +Test Case: Send more fragments than supported
> +=============================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=10s
> +
> +Sends 1 packet split in 5 fragments while the maximum number of supported
> +fragments per packet is 4.
> +
> +It expects:
> +
> + - 5 IP packets to be sent to the DUT.
> + - 0 TCP packets being forwarded back to the TESTER.
> + - 0 packets with a valid TCP checksum.
> +
> +
> +
> +Test Case: Send 3 frames and delay the 4th; no frames are forwarded back
> +========================================================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=3s
> +
> +Creates 1 packet split in 4 fragments. Sends the first 3 fragments and
> waits
> +until the ``flowttl`` timeout. Then sends the 4th fragment.
> +
> +It expects:
> +
> + - 4 IP packets to be sent to the DUT.
> + - 0 TCP packets being forwarded back to the TESTER.
> + - 0 packets with a valid TCP checksum.
> +
> +
> +
> +Test Case: Send jumbo frames
> +============================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=10s --enable-jumbo --max-pkt-
> len=9500
> +
> +Sets the NIC MTU to 9000 and sends 1K packets of 8900B split in 4
> fragments of
> +2500B at the most. The reassembled packet size will not be bigger than
> the
> +MTU previously defined.
> +
> +It expects:
> +
> + - 4K IP packets to be sent to the DUT.
> + - 1K TCP packets being forwarded back to the TESTER.
> + - 1K packets with a valid TCP checksum.
> +
> +
> +Test Case: Send jumbo frames without enable them in the app
> +===========================================================
> +
> +Sample command::
> +
> + ./examples/ip_reassembly/build/ip_reassembly -c 0x2 -n 4 -- -P -p 0x2 -
> -config "(1,0,1)" --maxflows=1024 --flowttl=10s
> +
> +Sends jumbo packets in the same way the previous test case does but
> without
> +enabling support within the sample app.
> +
> +It expects:
> +
> + - 4K IP packets to be sent to the DUT.
> + - 0 TCP packets being forwarded back to the TESTER.
> + - 0 packets with a valid TCP checksum.
> +
> +
> diff --git a/tests/TestSuite_ipv4_reassembly.py
> b/tests/TestSuite_ipv4_reassembly.py
> new file mode 100644
> index 0000000..e24576c
> --- /dev/null
> +++ b/tests/TestSuite_ipv4_reassembly.py
> @@ -0,0 +1,579 @@
> +# <COPYRIGHT_TAG>
> +
> +"""
> +DPDK Test suite.
> +
> +Test the IP reassembly feature
> +
> +"""
> +
> +import os
> +import time
> +from scapy.utils import struct, socket, PcapWriter
> +from scapy.layers.inet import Ether, IP, TCP, fragment
> +from scapy.route import *
> +
> +import dts
> +from test_case import TestCase
> +
> +
> +class IpReassemblyTestConfig(object):
> +
> + """
> + Helper class that encapsulates all the parameters used by the
> different
> + test cases components.
> + """
> +
> + #
> + #
> + # Utility methods and other non-test code.
> + #
> +
> + def __init__(self, test_case, **kwargs):
> + self.test_case = test_case
> + self.init()
> + for name in kwargs:
> + setattr(self, name, kwargs[name])
> +
> + def init(self):
> + self.cpu_config()
> + self.ports_config()
> + self.example_app_config()
> + self.packets_config()
> +
> + def cpu_config(self):
> + self.core_list = self.test_case.dut.get_core_list('1S/1C/1T')
> + self.core_mask = dts.create_mask(self.core_list)
> + self.memory_channels = self.test_case.dut.get_memory_channels()
> +
> + def ports_config(self):
> + dut_ports = self.test_case.dut.get_ports(self.test_case.nic)
> + dut_port = dut_ports[0]
> + tester_port = self.test_case.tester.get_local_port(dut_port)
> + self.tester_iface =
> self.test_case.tester.get_interface(tester_port)
> + self.dut_port_mask = dts.create_mask([dut_port])
> + self.queue_config = '({},{},{})'.format(dut_port, '0',
> self.core_list[0])
> +
> + def example_app_config(self):
> + self.maxflows = 1024
> + self.flowttl = '10s'
> + self.extra_args = ''
> +
> + def packets_config(self):
> + self.pcap_file = 'file.pcap'
> + self.number_of_frames = 1024
> + self.frags_per_frame = 4
> + self.src_ip = '2.1.1.0'
> + self.dst_ip = '1.1.1.111'
> + self.payload_size = 140
> + self.fragment_size = 40
> + self.mac_src = 'DE:AD:BE:EF:02:01'
> + self.mac_dst = 'DE:AD:BE:EF:01:02'
> + self.tcp_src_port = 1234
> + self.tcp_dst_port = 4321
> + self.identification = 1
> +
> +#
> +#
> +# Test class.
> +#
> +
> +
> +class TestIpReassembly(TestCase):
> +
> + #
> + #
> + #
> + # Test cases.
> + #
> +
> + def set_max_num_of_fragments(self, num_of_fragments=4):
> + """
> + Changes the maximum number of frames by modifying the example app
> code.
> + """
> +
> + # sed_command = (r"sed -i
> 's/\(\s*MAX_FRAG_NUM\s*=\)\s*[[:digit:]]*/\1 %d/' " +
> + # r"examples/ip_reassembly/ipv4_rsmbl.h")
> + # self.dut.send_expect("sed -i
> 's/CONFIG_RTE_LIBRTE_IP_FRAG_MAX_FRAG=.*$/CONFIG_RTE_LIBRTE_IP_FRAG_MAX_FR
> AG=%s/' ./config/common_linuxapp" %int(num_of_fragments), "# ")
> + # self.dut.send_expect(sed_command % int(num_of_fragments), '#',
> 60)
> +
> + self.dut.send_expect("sed -i
> 's/CONFIG_RTE_LIBRTE_IP_FRAG_MAX_FRAG=.*$/CONFIG_RTE_LIBRTE_IP_FRAG_MAX_FR
> AG=%s/' ./config/common_linuxapp" % int(num_of_fragments), "# ")
> + self.dut.send_expect("export RTE_TARGET=" + self.target, "#")
> + self.dut.send_expect("export RTE_SDK=`pwd`", "#")
> + self.dut.send_expect("rm -rf %s" % self.target, "# ", 5)
> + self.dut.build_install_dpdk(self.target)
> +
> + def set_tester_iface_mtu(self, iface, mtu=1500):
> + """
> + Set the interface MTU value.
> + """
> +
> + command = 'ip link set mtu {mtu} dev {iface}'
> + self.tester.send_expect(command.format(**locals()), '#')
> +
> + def compile_example_app(self):
> + """
> + Builds the example app and checks for errors.
> + """
> +
> + self.dut.send_expect('rm -rf examples/ip_reassembly/build', '#')
> + out = self.dut.build_dpdk_apps('examples/ip_reassembly')
> +# self.verify('Error' not in out and 'No such file' not in out,
> +# 'Compilation error')
> +
> + def execute_example_app(self):
> + """
> + Execute the example app and checks for errors.
> + """
> +
> + command = ('./examples/ip_reassembly/build/ip_reassembly -c
> {core_mask} ' +
> + '-n {memory_channels} -- -p {dut_port_mask} ' +
> + '--maxflows={maxflows} --flowttl={flowttl}
> {extra_args}')
> + self.dut.send_expect(command.format(**self.test_config.__dict__),
> 'IP_RSMBL: ')
> +
> + def tcp_ipv4_fragments(self, src_ip, identifier):
> + """
> + Using the Scapy API generates a packet with the given
> configuration
> + and returns a list containing fragmented packets.
> + """
> +
> + packet = Ether() / IP() / TCP() / ("X" *
> self.test_config.payload_size)
> + packet[Ether].src = self.test_config.mac_src
> + packet[Ether].dst = self.test_config.mac_dst
> + packet[IP].src = src_ip
> + packet[IP].dst = self.test_config.dst_ip
> + packet[IP].id = identifier
> + packet[TCP].sport = self.test_config.tcp_src_port
> + packet[TCP].dport = self.test_config.tcp_dst_port
> + return fragment(packet, fragsize=self.test_config.fragment_size)
> +
> + def increment_ip_address(self, addr, val):
> + """
> + Returns the next valid IP address from a given one, like
> + 10.1.1.254 -> 10.1.1.255 -> 10.1.2.0 -> 10.1.2.1
> + """
> +
> + ip2int = lambda ipstr: struct.unpack('!I',
> socket.inet_aton(ipstr))[0]
> + x = ip2int(addr)
> + int2ip = lambda n: socket.inet_ntoa(struct.pack('!I', n))
> + return int2ip(x + 1)
> +
> + def create_fragments(self):
> + """
> + Returns a list of fragmented IP packets by creating one packet at
> the
> + time, fragmenting it and adding it to a list.
> + It takes the packet information from the given configuration.
> + """
> +
> + all_fragments = []
> + src_ip = self.test_config.src_ip
> + for _ in range(self.test_config.number_of_frames):
> + src_ip = self.increment_ip_address(src_ip, 1)
> + identifier = self.test_config.identification % 0x10000
> + fragments = self.tcp_ipv4_fragments(src_ip, identifier)
> + all_fragments.extend(fragments)
> + self.test_config.identification += 1
> + return all_fragments
> +
> + def write_shuffled_pcap(self, fragments):
> + """
> + Receives a list of fragmented packets and writes them into a PCAP
> file
> + using the Scapy API.
> + Before saving the frames to a file it will reorder them like this:
> +
> + pkt0-frag3 -> pkt1-frag3 -> pkt2-frag3 -> ... -> pktN-frag3 ->
> + pkt0-frag2 -> pkt1-frag2 -> pkt2-frag2 -> ... -> pktN-frag2 ->
> + pkt0-frag1 -> pkt1-frag1 -> pkt2-frag1 -> ... -> pktN-frag1 ->
> + pkt0-frag0 -> pkt1-frag0 -> pkt2-frag0 -> ... -> pktN-frag0.
> + """
> +
> + writer = PcapWriter(self.test_config.pcap_file)
> + rounds = self.test_config.frags_per_frame
> + while rounds > 0:
> + index = rounds - 1
> + rounds -= 1
> + while index < len(fragments):
> + writer.write(fragments[index])
> + index += self.test_config.frags_per_frame
> + writer.close()
> +
> + def create_pcap_file(self):
> + """
> + Generates a valid PCAP file with the given configuration.
> + """
> +
> + fragments = self.create_fragments()
> + self.write_shuffled_pcap(fragments)
> +
> + def scapy_send_packets(self):
> + """
> + Calling scapy from the tester board sends the generated PCAP file
> to
> + the DUT
> + """
> +
> + self.tester.scapy_append('pcap = rdpcap("%s")' %
> self.test_config.pcap_file)
> + self.tester.scapy_append('sendp(pcap, iface="%s")' %
> self.test_config.tester_iface)
> + self.tester.scapy_execute()
> + time.sleep(5)
> +
> + def send_packets(self):
> + """
> + Goes trhough all the steps to send packets from the tester to the
> self.dut.
> + Generates the PCAP file, place it into the tester board, calls
> scapy and
> + finally removes the PCAP file.
> + """
> +
> + self.create_pcap_file()
> + self.tester.session.copy_file_to(self.test_config.pcap_file)
> + self.scapy_send_packets()
> + os.remove(self.test_config.pcap_file)
> + time.sleep(5)
> +
> + def tcpdump_start_sniffing(self):
> + """
> + Starts tcpdump in the background to sniff the tester interface
> where
> + the packets are transmitted to and from the self.dut.
> + All the captured packets are going to be stored in a file for a
> + post-analysis.
> + """
> +
> + command = ('tcpdump -w tcpdump.pcap -i %s 2>tcpdump.out &' %
> + self.test_config.tester_iface)
> + self.tester.send_expect('rm -f tcpdump.pcap', '#')
> + self.tester.send_expect(command, '#')
> +
> + def tcpdump_stop_sniff(self):
> + """
> + Stops the tcpdump process running in the background.
> + """
> +
> + self.tester.send_expect('killall tcpdump', '#')
> + # For the [pid]+ Done tcpdump... message after killing the
> process
> + self.tester.send_expect('cat tcpdump.out', '#')
> + time.sleep(3)
> +
> + def tcpdump_command(self, command):
> + """
> + Sends a tcpdump related command and returns an integer from the
> output
> + """
> +
> + result = self.tester.send_expect(command, '#')
> + return int(result.strip())
> +
> + def number_of_received_packets(self, tcp_port):
> + """
> + By reading the file generated by tcpdump it counts how many
> packets were
> + forwarded by the sample app and received in the self.tester. The
> sample app
> + will add a known MAC address for the test to look for.
> + """
> +
> + command = ('tcpdump -nn -e -v -r tcpdump.pcap tcp dst port
> {tcp_port} 2>/dev/null | ' +
> + 'grep -c 02:00:00:00:00') # MAC address used by the
> example app
> + return self.tcpdump_command(command.format(**locals()))
> +
> + def number_of_sent_packets(self, mac_src):
> + """
> + By reading the file generated by tcpdump it counts how many
> packets were
> + sent to the DUT searching for a given MAC address.
> + """
> +
> + command = ('tcpdump -nn -e -v -r tcpdump.pcap 2>/dev/null | ' +
> + 'grep -c -i {mac_src}')
> + return self.tcpdump_command(command.format(**locals()))
> +
> + def number_of_tcp_valid_checksum(self, tcp_port):
> + """
> + By reading the file generated by tcpdump it counts how many
> packets have
> + a valid TCP checksum or how many packets were correctly assembled.
> + """
> +
> + command = ('tcpdump -nn -e -v -r tcpdump.pcap tcp dst port
> {tcp_port} 2>/dev/null | ' +
> + 'grep -c -E "cksum.*correct"')
> + return self.tcpdump_command(command.format(**locals()))
> +
> + def send_n_siff_packets(self):
> + """
> + Sends the packets while tcpdump is sniffing on the background.
> + """
> +
> + self.tcpdump_start_sniffing()
> + self.send_packets()
> + self.tcpdump_stop_sniff()
> +
> + def verify_sent_packets(self, expected):
> + """
> + Verifies if the number of sent packets is the expected.
> + """
> +
> + sent_packets =
> self.number_of_sent_packets(self.test_config.mac_src)
> + print 'sent packets: %d - expected: %d' % (sent_packets, expected)
> + self.verify(sent_packets == expected, 'Not all fragments have
> been sent')
> +
> + def verify_received_packets(self, expected):
> + """
> + Verifies if the number of received packets is the expected.
> + """
> +
> + received_packets =
> self.number_of_received_packets(self.test_config.tcp_dst_port)
> + print 'received packets: %d - expected: %d' % (received_packets,
> expected)
> + self.verify(received_packets == expected,
> + 'Not all frames have been forwarded')
> +
> + def verify_tcp_valid_checksum(self, expected):
> + """
> + Verifies if the number of packets with a valid TCP checksum is
> the expected.
> + """
> +
> + tcp_valid_checksum =
> self.number_of_tcp_valid_checksum(self.test_config.tcp_dst_port)
> + print 'tcp valid: %d - expected: %d' % (tcp_valid_checksum,
> expected)
> + self.verify(tcp_valid_checksum == expected,
> + 'Not all TCP packets have valid checksum')
> +
> + def verify_all_with_maxflows(self):
> + """
> + Runs a common verification among different test cases were the
> number
> + of sent packets is bigger than the maxflows value which means
> that
> + only maxflows packets are expected to be received and valid.
> + """
> +
> + self.verify_sent_packets(self.test_config.number_of_frames *
> + self.test_config.frags_per_frame)
> + self.verify_received_packets(self.test_config.maxflows)
> + self.verify_tcp_valid_checksum(self.test_config.maxflows)
> +
> + def verify_all(self):
> + """
> + Runs a common verification among different test cases were the
> number
> + of sent packets is equal to the maxflows value. It expects to
> receive
> + the same number of frames that were sent.
> + """
> +
> + self.verify_sent_packets(self.test_config.number_of_frames *
> + self.test_config.frags_per_frame)
> + self.verify_received_packets(self.test_config.number_of_frames)
> + self.verify_tcp_valid_checksum(self.test_config.number_of_frames)
> +
> + def set_up_all(self):
> + """
> + Run at the start of each test suite.
> +
> +
> + Builds the sample app and set the shell prompt to a known and
> value.
> + """
> +
> + self.tester.send_expect('export PS1="# "', '#')
> + self.compile_example_app()
> +
> + def test_send_1K_frames_split_in_4_and_1K_maxflows(self):
> + """
> + Sends 1K frames split in 4 fragments each using
> + 1K maxflows.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self)
> +
> + self.execute_example_app()
> + self.send_n_siff_packets()
> +
> + self.verify_all()
> +
> + def test_send_2K_frames_split_in_4_and_1K_maxflows(self):
> + """
> + Sends 2K frames while the maxflow value is only 1K.
> + Only 1K frames are expected to be forwarded.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self,
> number_of_frames=2048)
> +
> + self.execute_example_app()
> + self.send_n_siff_packets()
> +
> + self.verify_all_with_maxflows()
> +
> + def test_send_4K_frames_split_in_7_and_4K_maxflows(self):
> + """
> + Sends 4K frames split into 7 fragments each.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self,
> + number_of_frames=4096,
> + frags_per_frame=7,
> + payload_size=230,
> + maxflows=4096,
> + flowttl='40s')
> +
> + try:
> + self.set_max_num_of_fragments(7)
> + self.compile_example_app()
> + self.execute_example_app()
> + self.send_n_siff_packets()
> + self.verify_all()
> + self.dut.send_expect('^C', '# ')
> + time.sleep(5)
> + self.set_max_num_of_fragments(4)
> + time.sleep(5)
> +
> + except Exception as e:
> + self.dut.send_expect('^C', '# ')
> + time.sleep(2)
> + self.set_max_num_of_fragments()
> + self.compile_example_app()
> + raise e
> +
> + def test_packets_are_forwarded_after_ttl_timeout(self):
> + """
> + Sends +1K frames with 1K maxflwos - expects only
> + 1K frames to be forwarded. Then it waits until flowttl timeout
> and
> + sends 1K frames. 1K frames must be forwarded back.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self,
> + number_of_frames=1100,
> + flowttl='3s')
> +
> + self.execute_example_app()
> +
> + self.send_n_siff_packets()
> + self.verify_all_with_maxflows()
> +
> + time.sleep(5)
> +
> + self.test_config.number_of_frames = 1024
> + self.send_n_siff_packets()
> + self.verify_all()
> +
> + def test_only_maxflows_packets_are_forwarded(self):
> + """
> + Using a maxflow of 1023 sends 1K frames expecting 1023 back.
> + Then sends 1023 frames, expecting 1023 back again. And after the
> flowttl
> + timeout sends 1K frames expecting all of them to be forwarded
> back.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self,
> + maxflows=1023,
> + flowttl='5s')
> +
> + self.execute_example_app()
> +
> + self.send_n_siff_packets()
> + self.verify_all_with_maxflows()
> +
> + self.test_config.number_of_frames = 1023
> + self.send_n_siff_packets()
> + self.verify_all()
> +
> + time.sleep(5)
> +
> + self.test_config.number_of_frames = 1024
> + self.send_n_siff_packets()
> + self.verify_all_with_maxflows()
> +
> + def test_send_more_fragments_than_supported(self):
> + """
> + Sends 1 frame split in 5 fragments. Since the max number of
> + fragments is set to 4 by default, the packet can't be forwarded
> back.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self,
> + number_of_frames=1,
> + frags_per_frame=5,
> + payload_size=180)
> + self.execute_example_app()
> +
> + self.send_n_siff_packets()
> +
> + self.verify_sent_packets(self.test_config.number_of_frames *
> + self.test_config.frags_per_frame)
> + self.verify_received_packets(0)
> + self.verify_tcp_valid_checksum(0)
> +
> + def test_send_delayed_fragment_packet_is_forwarded(self):
> + """
> + Creates 1 frame split in 4. Sends 3 fragments first, waits
> + for the flowttl to timeout and then sends the 4th. The packet
> can't
> + be forwarded back.
> + """
> +
> + self.test_config = IpReassemblyTestConfig(self,
> + number_of_frames=1,
> + flowttl='3s')
> +
> + self.execute_example_app()
> + self.tcpdump_start_sniffing()
> +
> + fragments = self.create_fragments()
> + self.write_shuffled_pcap(fragments[:3])
> + self.tester.session.copy_file_to(self.test_config.pcap_file)
> + self.scapy_send_packets()
> + os.remove(self.test_config.pcap_file)
> +
> + time.sleep(3)
> +
> + self.write_shuffled_pcap(fragments[3:])
> + self.tester.session.copy_file_to(self.test_config.pcap_file)
> + self.scapy_send_packets()
> + os.remove(self.test_config.pcap_file)
> +
> + self.tcpdump_stop_sniff()
> +
> + self.verify_sent_packets(self.test_config.number_of_frames *
> + self.test_config.frags_per_frame)
> + self.verify_received_packets(0)
> + self.verify_tcp_valid_checksum(0)
> +
> + def test_send_jumbo_frames(self):
> + """
> + Sends 1K jumbo frames using the right configuration.
> + Expects all the frames to be forwarded back.
> + """
> +
> + mtu = 9000
> + self.test_config = IpReassemblyTestConfig(self,
> + payload_size=mtu - 100,
> + fragment_size=2500)
> + try:
> + self.set_tester_iface_mtu(self.test_config.tester_iface, mtu)
> + self.execute_example_app()
> + self.send_n_siff_packets()
> + self.verify_all()
> + except Exception as e:
> + self.set_tester_iface_mtu(self.test_config.tester_iface)
> + raise e
> +
> + def test_send_jumbo_frames_with_wrong_arguments(self):
> + """
> + Sends 1K jumbo frames without enabling the jumbo frames
> + within the sample app. Expects zero frames to be forwarded back.
> + """
> +
> + mtu = 9000
> + self.test_config = IpReassemblyTestConfig(self,
> + payload_size=mtu - 100,
> + fragment_size=2500)
> + try:
> + self.set_tester_iface_mtu(self.test_config.tester_iface, mtu)
> + self.set_max_num_of_fragments(4)
> + self.compile_example_app()
> + self.execute_example_app()
> + self.send_n_siff_packets()
> +
> + self.verify_sent_packets(self.test_config.number_of_frames *
> + self.test_config.frags_per_frame)
> + self.verify_all()
> + except Exception as e:
> + self.set_tester_iface_mtu(self.test_config.tester_iface)
> + raise e
> +
> + def tear_down(self):
> + """
> + Run after each test case.
> + """
> +
> + self.dut.send_expect('^C', '# ')
> +
> + def tear_down_all(self):
> + """
> + Run after each test suite.
> + """
> +
> + self.dut.kill_all()
> --
> 1.7.7
More information about the dts
mailing list