Re: [dts] [PATCH V1] framework/packet: update packet module of dts

["Chen, Zhaoyan" <zhaoyan.chen@intel.com>]

Acked-by: Chen, Zhaoyan <zhaoyan.chen@intel.com>



Regards,
Zhaoyan Chen


> -----Original Message-----
> From: dts [mailto:dts-bounces@dpdk.org] On Behalf Of Qimai Xiao
> Sent: Saturday, September 28, 2019 2:06 AM
> To: dts@dpdk.org
> Cc: Xiao, QimaiX <qimaix.xiao@intel.com>
> Subject: [dts] [PATCH V1] framework/packet: update packet module of dts
> 
> update API of packet and some other optimization
> 
> Signed-off-by: Qimai Xiao <qimaix.xiao@intel.com>
> ---
>  framework/packet.py | 665 +++++++++++++++++++++++---------------------
>  1 file changed, 354 insertions(+), 311 deletions(-)
> 
> diff --git a/framework/packet.py b/framework/packet.py index 502d85c..05b2367
> 100755
> --- a/framework/packet.py
> +++ b/framework/packet.py
> @@ -33,35 +33,19 @@
>  Generic packet create, transmit and analyze module  Base on scapy(python program
> for packet manipulation)  """
> -import os
> -import time
> -import sys
> -import re
> -import signal
> -import random
> -import subprocess
> -import shlex        # separate command line for pipe
> -from uuid import uuid4
> -from settings import FOLDERS
> -
> -import struct
> +
>  from socket import AF_INET6
> -from scapy.all import conf
> -from scapy.utils import wrpcap, rdpcap, hexstr -from scapy.layers.inet import Ether,
> IP, TCP, UDP, ICMP -from scapy.layers.inet6 import IPv6, IPv6ExtHdrRouting,
> IPv6ExtHdrFragment -from scapy.layers.l2 import Dot1Q, ARP, GRE
> +from scapy.all import *
>  from scapy.layers.sctp import SCTP, SCTPChunkData -from scapy.sendrecv import
> sniff -from scapy.route import * -from scapy.packet import bind_layers, Raw -from
> scapy.sendrecv import sendp -from scapy.arch import get_if_hwaddr -from pexpect
> import pxssh
> 
>  # load extension layers
>  exec_file = os.path.realpath(__file__)
>  DTS_PATH = exec_file.replace('/framework/packet.py', '')
> +# exec_file might be .pyc file, if so, remove 'c'.
> +TMP_PATH = DTS_PATH[:-1] + '/output/tmp/pcap/' if exec_file.endswith('.pyc')
> else DTS_PATH + '/output/tmp/pcap/'
> +
> +if not os.path.exists(TMP_PATH):
> +    os.system('mkdir -p %s' % TMP_PATH)
>  DEP_FOLDER = DTS_PATH + '/dep'
>  sys.path.append(DEP_FOLDER)
> 
> @@ -70,9 +54,8 @@ from nvgre import NVGRE, IPPROTO_NVGRE  from lldp import
> LLDP, LLDPManagementAddress  from Dot1BR import Dot1BR
> 
> -# get tester logger
> -from logger import getLogger
> -logger = getLogger('tester')
> +from utils import convert_ip2int
> +from utils import convert_int2ip
> 
>  # for saving command history
>  from utils import get_backtrace_object
> @@ -150,7 +133,16 @@ class scapy(object):
> 
>      def __init__(self):
>          self.pkt = None
> -        pass
> +        self.pkts = []
> +
> +    def append_pkts(self):
> +        self.pkts.append(self.pkt)
> +
> +    def update_pkts(self):
> +        if not self.pkts:  # update pkt to a null pkt list.
> +            self.pkts.append(self.pkt)
> +        else:
> +            self.pkts[-1] = self.pkt
> 
>      def assign_pkt(self, pkt):
>          self.pkt = pkt
> @@ -179,14 +171,14 @@ class scapy(object):
>          if type is not None:
>              pkt_layer.type = type
> 
> -    def strip_vlan(self, element):
> +    def strip_vlan(self, element, p_index=0):
>          value = None
> 
> -        if self.pkt.haslayer('Dot1Q') is 0:
> +        if self.pkts[p_index].haslayer('Dot1Q') is 0:
>              return None
> 
>          if element == 'vlan':
> -            value = int(str(self.pkt[Dot1Q].vlan))
> +            value = int(str(self.pkts[p_index][Dot1Q].vlan))
>          return value
> 
>      def etag(self, pkt_layer, ECIDbase=0, prio=0, type=None):
> @@ -197,19 +189,19 @@ class scapy(object):
>          if type is not None:
>              pkt_layer.type = type
> 
> -    def strip_etag(self, element):
> +    def strip_etag(self, element, p_index=0):
>          value = None
> 
> -        if self.pkt.haslayer('Dot1BR') is 0:
> +        if self.pkts[p_index].haslayer('Dot1BR') is 0:
>              return None
> 
>          if element == 'ECIDbase':
> -            value = int(str(self.pkt[Dot1BR].ECIDbase))
> +            value = int(str(self.pkts[p_index][Dot1BR].ECIDbase))
>          return value
> 
> -    def strip_layer2(self, element):
> +    def strip_layer2(self, element, p_index=0):
>          value = None
> -        layer = self.pkt.getlayer(0)
> +        layer = self.pkts[p_index].getlayer(0)
>          if layer is None:
>              return None
> 
> @@ -222,9 +214,9 @@ class scapy(object):
> 
>          return value
> 
> -    def strip_layer3(self, element):
> +    def strip_layer3(self, element, p_index=0):
>          value = None
> -        layer = self.pkt.getlayer(1)
> +        layer = self.pkts[p_index].getlayer(1)
>          if layer is None:
>              return None
> 
> @@ -237,9 +229,9 @@ class scapy(object):
> 
>          return value
> 
> -    def strip_layer4(self, element):
> +    def strip_layer4(self, element, p_index=0):
>          value = None
> -        layer = self.pkt.getlayer(2)
> +        layer = self.pkts[p_index].getlayer(2)
>          if layer is None:
>              return None
> 
> @@ -252,7 +244,8 @@ class scapy(object):
> 
>          return value
> 
> -    def ipv4(self, pkt_layer, frag=0, src="127.0.0.1", proto=None, tos=0,
> dst="127.0.0.1", chksum=None, len=None, version=4, flags=None, ihl=None, ttl=64,
> id=1, options=None):
> +    def ipv4(self, pkt_layer, frag=0, src="127.0.0.1", proto=None, tos=0,
> dst="127.0.0.1", chksum=None, len=None,
> +             version=4, flags=None, ihl=None, ttl=64, id=1, options=None):
>          pkt_layer.frag = frag
>          pkt_layer.src = src
>          if proto is not None:
> @@ -287,7 +280,7 @@ class scapy(object):
>          pkt_layer.src = src
>          pkt_layer.dst = dst
> 
> -    def tcp(self, pkt_layer, src=53, dst=53, flags=None, len=None, chksum=None):
> +    def tcp(self, pkt_layer, src=53, dst=53, flags=0, len=None, chksum=None):
>          pkt_layer.sport = src
>          pkt_layer.dport = dst
>          if flags is not None:
> @@ -328,66 +321,6 @@ class scapy(object):
>      def vxlan(self, pkt_layer, vni=0):
>          pkt_layer.vni = vni
> 
> -    def read_pcap(self, file):
> -        pcap_pkts = []
> -        try:
> -            pcap_pkts = rdpcap(file)
> -        except:
> -            pass
> -
> -        return pcap_pkts
> -
> -    def write_pcap(self, file):
> -        try:
> -            wrpcap(file, self.pkt)
> -        except:
> -            pass
> -
> -    def send_pcap_pkt(self, crb=None, file='', intf='', count=1):
> -        if intf == '' or file == '' or crb is None:
> -            print "Invalid option for send packet by scapy"
> -            return
> -
> -        content = 'pkts=rdpcap(\"%s\");sendp(pkts, iface=\"%s\",
> count=\"%s\" );exit()' % (file, intf, count)
> -        cmd_file = '/tmp/scapy_%s.cmd' % intf
> -
> -        crb.create_file(content, cmd_file)
> -        crb.send_expect("scapy -c scapy_%s.cmd &" % intf, "# ")
> -
> -    def print_summary(self):
> -        # save command into test case history
> -        history_list = get_backtrace_object('test_case.py', 'test_history')
> -        if type(history_list) is list:
> -            history_list.append({"command": "p=%s" % self.pkt.command(), "name":
> "Scapy", "output": ""})
> -
> -        logger.info("%s" % self.pkt.command())
> -
> -    def send_pkt(self, intf='', count=1):
> -        self.print_summary()
> -
> -        if intf != '':
> -            # wait few seconds for link ready
> -            countdown = 600
> -            while countdown:
> -                link_st = subprocess.check_output("ip link show %s" % intf,
> -                                                  stderr=subprocess.STDOUT,
> -                                                  shell=True)
> -                if "LOWER_UP" in link_st:
> -                    break
> -                else:
> -                    time.sleep(0.01)
> -                    countdown -= 1
> -                    continue
> -
> -            # fix fortville can't receive packets with 00:00:00:00:00:00
> -            if self.pkt.getlayer(0).src == "00:00:00:00:00:00":
> -                self.pkt.getlayer(0).src = get_if_hwaddr(intf)
> -            sendp(self.pkt, iface=intf, count=count)
> -
> -            # save command into test case history
> -            history_list = get_backtrace_object('test_case.py', 'test_history')
> -            if type(history_list) is list:
> -                history_list.append({"command": "sendp(p, iface=\"%s\")" % intf, "name":
> "Scapy", "output": ""})
> 
>  class Packet(object):
> 
> @@ -413,10 +346,11 @@ class Packet(object):
>          'IPv6_SCTP': {'layers': ['ether', 'ipv6', 'sctp', 'raw'], 'cfgload': True},
>      }
> 
> -    def __init__(self, **options):
> +    def __init__(self, pkt_str=None, **options):
>          """
>          pkt_type: description of packet type
>                    defined in def_packet
> +        args: specify a packet with a string explicitly, will ignore
> + options
>          options: special option for Packet module
>                   pkt_len: length of network packet
>                   ran_payload: whether payload of packet is random @@ -424,14 +358,41
> @@ class Packet(object):
>                   pkt_gen: packet generator type
>                            now only support scapy
>          """
> -        self.pkt_layers = []
> -        self.pkt_len = 64
>          self.pkt_opts = options
> +        self.pkt_layers = []
> 
> -        self.pkt_type = "UDP"
> +        if 'pkt_gen' in self.pkt_opts.keys():
> +            if self.pkt_opts['pkt_gen'] == 'scapy':
> +                self.pktgen = scapy()
> +            else:
> +                print "Not support other pktgen yet!!!"
> +        else:
> +            self.pktgen = scapy()
> 
> -        if 'pkt_type' in self.pkt_opts.keys():
> -            self.pkt_type = self.pkt_opts['pkt_type']
> +        if pkt_str is not None and type(pkt_str) == str:
> +            self._scapy_str_to_pkt(pkt_str)
> +        elif len(options) == 0:
> +            pass
> +        else:
> +            self._add_pkt(self.pkt_opts)
> +        if self.pktgen.pkt is not None:
> +            self.pktgen.append_pkts()
> +
> +    def __len__(self):
> +        return len(self.pktgen.pkts)
> +
> +    def __getitem__(self, item):
> +        return self.pktgen.pkts[item]
> +
> +    def _add_pkt(self, options):
> +        """
> +        :param options: packt configuration, dictionary type
> +        :return:
> +        """
> +        self.pkt_len = 64
> +        self.pkt_type = "UDP"
> +        if 'pkt_type' in options.keys():
> +            self.pkt_type = options['pkt_type']
> 
>          if self.pkt_type in self.def_packet.keys():
>              self.pkt_layers = self.def_packet[self.pkt_type]['layers']
> @@ -441,21 +402,8 @@ class Packet(object):
>          else:
>              self._load_pkt_layers()
> 
> -        if 'pkt_len' in self.pkt_opts.keys():
> -            self.pkt_len = self.pkt_opts['pkt_len']
> -
> -        if 'pkt_file' in self.pkt_opts.keys():
> -            self.uni_name = self.pkt_opts['pkt_file']
> -        else:
> -            self.uni_name = '/tmp/' + str(uuid4()) + '.pcap'
> -
> -        if 'pkt_gen' in self.pkt_opts.keys():
> -            if self.pkt_opts['pkt_gen'] == 'scapy':
> -                self.pktgen = scapy()
> -            else:
> -                print "Not support other pktgen yet!!!"
> -        else:
> -            self.pktgen = scapy()
> +        if 'pkt_len' in options.keys():
> +            self.pkt_len = options['pkt_len']
> 
>          self._load_assign_layers()
> 
> @@ -483,32 +431,227 @@ class Packet(object):
>              raw_confs['payload'] = payload
>              self.config_layer('raw', raw_confs)
> 
> -    def send_pkt(self, crb=None, tx_port='', auto_cfg=True, count=1):
> -        if tx_port == '':
> -            print "Invalid Tx interface"
> -            return
> +    def _scapy_str_to_pkt(self, scapy_str):
> +        """
> 
> -        self.tx_port = tx_port
> +        :param scapy_str: packet str, eg. 'Ether()/IP()/UDP()'
> +        :return: None
> +        """
> +        layer_li = [re.sub('\(.*?\)', '', i) for i in scapy_str.split('/')]
> +        self.pkt_type = '_'.join(layer_li)
> +        self._load_pkt_layers()
> +        pkt = eval(scapy_str)
> +        self.pktgen.assign_pkt(pkt)
> 
> -        # check with port type
> -        if 'ixia' in self.tx_port:
> -            print "Not Support Yet"
> +    def append_pkt(self, args=None, **kwargs):
> +        """
> +        :param args: take str type as pkt to append
> +        :param kwargs: take dictory type as pkt to append
> +        :return: None
> +        """
> +        if isinstance(args, str):
> +            self._scapy_str_to_pkt(args)
> +        elif isinstance(kwargs, dict):
> +            self.pkt_opts = kwargs
> +            if hasattr(self, 'configured_layer_raw'):
> +                delattr(self, 'configured_layer_raw')
> +            self._add_pkt(kwargs)
> +        self.pktgen.append_pkts()
> +
> +    def generate_random_pkts(self, dstmac=None, pktnum=100, random_type=None,
> ip_increase=True, random_payload=False,
> +                             options=None):
> +        """
> +        # generate random packets
> +        :param dstmac: specify the dst mac
> +        :param pktnum: packet number to generate
> +        :param random_type: specify random packet type
> +        :param ip_increase: auto increase ip value
> +        :param random_payload: if True, generate random packets with random
> payload
> +        :param options: packet layer configuration
> +        :return: None
> +        """
> 
> -        if crb is not None:
> -            self.pktgen.write_pcap(self.uni_name)
> -            crb.session.copy_file_to(self.uni_name)
> -            pcap_file = self.uni_name.split('/')[2]
> -            self.pktgen.send_pcap_pkt(
> -                crb=crb, file=pcap_file, intf=self.tx_port, count=count)
> +        random_type = ['TCP', 'UDP', 'IPv6_TCP', 'IPv6_UDP'] if random_type is None
> else random_type
> +        options = {'ip': {'src': '192.168.0.1', 'dst': '192.168.1.1'},
> +                   'layers_config': []} if options is None else options
> +        # give a default value to ip
> +        try:
> +            src_ip_num = convert_ip2int(options['ip']['src'])
> +        except:
> +            src_ip_num = 0
> +        try:
> +            dst_ip_num = convert_ip2int(options['ip']['dst'])
> +        except:
> +            dst_ip_num = 0
> +
> +        for i in range(pktnum):
> +            # random the packet type
> +            self.pkt_type = random.choice(random_type)
> +            self.pkt_layers = self.def_packet[self.pkt_type]['layers']
> +            self.check_layer_config()
> +            self.pktgen.add_layers(self.pkt_layers)
> +            # hardcode src/dst port for some protocol may cause issue
> +            if "TCP" in self.pkt_type:
> +                self.config_layer('tcp', {'src': 65535, 'dst': 65535})
> +            if "UDP" in self.pkt_type:
> +                self.config_layer('udp', {'src': 65535, 'dst': 65535})
> +            if options.has_key('layers_config'):
> +                self.config_layers(options['layers_config'])
> +            if dstmac:
> +                self.config_layer('ether', {'dst': '%s' % dstmac})
> +            # generate auto increase dst ip packet
> +            if ip_increase:
> +                if 'v6' in self.pkt_type:
> +                    dstip = convert_int2ip(dst_ip_num, ip_type=6)
> +                    srcip = convert_int2ip(src_ip_num, ip_type=6)
> +                    self.config_layer('ipv6', config={'dst': '%s' % (dstip), 'src': '%s' % srcip})
> +                else:
> +                    dstip = convert_int2ip(dst_ip_num, ip_type=4)
> +                    srcip = convert_int2ip(src_ip_num, ip_type=4)
> +                    self.config_layer('ipv4', config={'dst': '%s' % (dstip), 'src': '%s' % srcip})
> +                dst_ip_num += 1
> +            # generate random payload of packet
> +            if random_payload and self.def_packet[self.pkt_type]['cfgload']:
> +                # TCP packet has a default flags S, packet should not load data, so set it to A
> if has payload
> +                if 'TCP' in self.pkt_type:
> +                    self.config_layer('tcp', {'src': 65535, 'dst':
> + 65535, 'flags': 'A'})
> +
> +                payload_len = random.randint(64, 100)
> +                payload = []
> +                for _ in range(payload_len):
> +                    payload.append("%02x" % random.randrange(0, 255))
> +                self.config_layer('raw', config={'payload': payload})
> +            self.pktgen.append_pkts()
> +
> +    def save_pcapfile(self, crb=None, filename='saved_pkts.pcap'):
> +        """
> +
> +        :param crb: session or crb object
> +        :param filename: location and name for packets to be saved
> +        :return: None
> +        """
> +        # save pkts to pcap file to local path, then copy to remote tester tmp directory,
> +        if crb:
> +            trans_path = crb.tmp_file
> +            file_name = filename
> +            if os.path.isabs(filename):  # check if the given filename with a abs path
> +                file_dir = os.path.dirname(filename)
> +                out = crb.send_expect('ls -d %s' % file_dir, '# ', verify=True)
> +                if not isinstance(out, str):
> +                    raise Exception('%s may not existed on %s' % (file_dir, crb.name))
> +                wrpcap(filename, self.pktgen.pkts)
> +                trans_path = os.path.abspath(filename)
> +                file_name = filename.split(os.path.sep)[-1]
> +            # write packets to local tmp path $dts/ouput/tmp/pcap/
> +            wrpcap(TMP_PATH + file_name, self.pktgen.pkts)
> +            # copy to remote tester tmp path /tmp/tester
> +            crb.session.copy_file_to(TMP_PATH + file_name, trans_path)
>          else:
> -            self.pktgen.send_pkt(intf=self.tx_port, count=count)
> +            wrpcap(filename, self.pktgen.pkts)
> 
> -    def check_layer_config(self, layer, config):
> +    def read_pcapfile(self, filename, crb=None):
> +        """
> +
> +        :param filename: packet to be read from
> +        :param crb: session or crb object
> +        :return: scapy type packet
> +        """
> +        # read pcap file from local or remote, then append to pkts list
> +        # if crb, read pakcet from remote server, else read from local location
> +        if crb:
> +            out = crb.send_expect('ls -d %s' % filename, '# ', verify=True)
> +            if not isinstance(out, str):
> +                raise Exception('%s may not existed on %s' % (filename, crb.name))
> +            crb.session.copy_file_from(filename, TMP_PATH)
> +            p = rdpcap(TMP_PATH + filename.split(os.path.sep)[-1])
> +        else:
> +            p = rdpcap(filename)
> +        if len(p) == 0:
> +            return None
> +        self.pktgen.assign_pkt(p[-1])
> +        for i in p:
> +            self.pktgen.pkts.append(i)
> +        return p
> +
> +    def _send_pkt(self, crb, tx_port='', count=1, send_bg=False, loop=0, inter=0,
> timeout=15):
> +        """
> +
> +        :param crb: session or crb object
> +        :param tx_port: ether to send packet
> +        :param count: send times
> +        :param send_bg: send packet background
> +        :param loop: send packet in a loop
> +        :param inter: interval time
> +        :return: None
> +        """
> +        # save pkts to local pcap file, then copy to remote tester tmp
> + directory
> +
> +        time_stamp = str(time.time())
> +        pcap_file = 'scapy_{}.pcap'.format(tx_port) + time_stamp
> +        self.save_pcapfile(crb, pcap_file)
> +        scapy_cmd = 'scapy_{}.cmd'.format(tx_port) + time_stamp
> +        cmd_str = 'from scapy.all import *\np=rdpcap("%s")\nprint("packet ready for
> sending...")\nfor i in p:\n\tprint(i.command())\nsendp(p, iface="%s", count=%d,
> loop=%d, inter=%0.3f)' % (
> +            crb.tmp_file + pcap_file, tx_port, count, loop, inter)
> +        # write send cmd file to local tmp directory then copy to remote tester tmp
> folder
> +        with open(TMP_PATH + scapy_cmd, 'w') as f:
> +            f.write(cmd_str)
> +        crb.session.copy_file_to(TMP_PATH + scapy_cmd, crb.tmp_file)
> +
> +        if send_bg:  # if send_bg create a new session to execute send action
> +            session_prefix = 'scapy_bg_session'
> +            scapy_session = crb.create_session(session_prefix + time_stamp)
> +            scapy_session.send_command('python %s' % crb.tmp_file + scapy_cmd)
> +        else:
> +            crb.send_expect('python %s' % crb.tmp_file + scapy_cmd, '# ',
> timeout=timeout)
> +        return crb.tmp_file + scapy_cmd
> +
> +    def send_pkt(self, crb, tx_port='', count=1, interval=0, timeout=15):
> +        self._send_pkt(crb, tx_port, count, inter=interval,
> + timeout=timeout)
> +
> +    def send_pkt_bg(self, crb, tx_port='', count=-1, loop=1, interval=0, timeout=3):
> +        return self._send_pkt(crb, tx_port=tx_port, count=count, send_bg=True,
> loop=loop, inter=interval,
> +                              timeout=timeout)
> +
> +    def stop_send_pkt_bg(self, crb, filenames):
> +        # stop sending action
> +        pids = []
> +        if isinstance(filenames, list):
> +            for file in filenames:
> +                out = crb.send_expect('ps -ef |grep %s|grep -v grep' % file, expected='# ')
> +                try:
> +                    pids.append(re.search('\d+', out).group())
> +                except AttributeError as e:
> +                    print(e, ' :%s not killed' % file)
> +        else:
> +            out = crb.send_expect('ps -ef |grep %s|grep -v grep' % filenames, expected='#
> ')
> +            try:
> +                pids.append(re.search('\d+', out).group())
> +            except AttributeError as e:
> +                print(e, ' :%s not killed' % filenames)
> +        pid = ' '.join(pids)
> +        if pid:
> +            crb.send_expect('kill -9 %s' % pid, expected='# ')
> +        for i in crb.sessions:
> +            if i.name.startswith('scapy_bg_session'):
> +                crb.destroy_session(i)
> +
> +    def check_layer_config(self):
>          """
>          check the format of layer configuration
>          every layer should has different check function
>          """
> -        pass
> +        for layer in self.pkt_layers:
> +            found = False
> +            l_type = layer.lower()
> +
> +            for types in LayersTypes.values():
> +                if l_type in types:
> +                    found = True
> +                    break
> +
> +            if found is False:
> +                self.pkt_layers.remove(l_type)
> +                print "INVAILD LAYER TYPE [%s]" % l_type.upper()
> 
>      def assign_layers(self, layers=None):
>          """
> @@ -532,6 +675,8 @@ class Packet(object):
>                  print "INVAILD LAYER TYPE [%s]" % l_type.upper()
> 
>          self.pktgen.add_layers(self.pkt_layers)
> +        if layers:
> +            self.pktgen.update_pkts()
> 
>      def _load_pkt_layers(self):
>          name2type = {
> @@ -590,9 +735,9 @@ class Packet(object):
>              else:
>                  self.config_layer('raw', {'payload': ['00'] * 18})
> 
> -        if "MAC_IP_IPv6" in self.pkt_type or\
> -           "MAC_IP_NVGRE" in self.pkt_type or \
> -           "MAC_IP_UDP_VXLAN" in self.pkt_type:
> +        if "MAC_IP_IPv6" in self.pkt_type or \
> +                "MAC_IP_NVGRE" in self.pkt_type or \
> +                "MAC_IP_UDP_VXLAN" in self.pkt_type:
>              if "IPv6_SCTP" in self.pkt_type:
>                  self.config_layer('ipv6', {'nh': 132})
>              if "IPv6_ICMP" in self.pkt_type:
> @@ -601,6 +746,8 @@ class Packet(object):
>                  self.config_layer('raw', {'payload': ['00'] * 40})
>              else:
>                  self.config_layer('raw', {'payload': ['00'] * 18})
> +        if 'TCP' in self.pkt_type:
> +            self.config_layer('tcp', {'flags': 0})
> 
>      def config_layer(self, layer, config={}):
>          """
> @@ -613,22 +760,23 @@ class Packet(object):
>              print "INVALID LAYER ID %s" % layer
>              return False
> 
> -        if self.check_layer_config(layer, config) is False:
> +        if self.check_layer_config() is False:
>              return False
> 
>          if 'inner' in layer:
>              layer = layer[6:]
> 
>          pkt_layer = self.pktgen.pkt.getlayer(idx)
> -        layer_conf = getattr(self, "_config_layer_%s" % layer)
> +        layer_conf = getattr(self.pktgen, layer)
>          setattr(self, 'configured_layer_%s' % layer, True)
> 
> -        return layer_conf(pkt_layer, config)
> +        layer_conf(pkt_layer, **config)
> 
>      def config_layers(self, layers=None):
>          """
>          Configure packet with multi configurations
>          """
> +        layers = [] if layers is None else layers  # None object is not
> + Iterable
>          for layer in layers:
>              name, config = layer
>              if name not in self.pkt_layers:
> @@ -638,65 +786,28 @@ class Packet(object):
>                  print "[%s] failed to configure!!!" % name
>                  raise
> 
> -    def _config_layer_ether(self, pkt_layer, config):
> -        return self.pktgen.ether(pkt_layer, **config)
> -
> -    def _config_layer_mac(self, pkt_layer, config):
> -        return self.pktgen.ether(pkt_layer, **config)
> -
> -    def _config_layer_vlan(self, pkt_layer, config):
> -        return self.pktgen.vlan(pkt_layer, **config)
> -
> -    def _config_layer_etag(self, pkt_layer, config):
> -        return self.pktgen.etag(pkt_layer, **config)
> -
> -    def _config_layer_ipv4(self, pkt_layer, config):
> -        return self.pktgen.ipv4(pkt_layer, **config)
> -
> -    def _config_layer_ipv6(self, pkt_layer, config):
> -        return self.pktgen.ipv6(pkt_layer, **config)
> -
> -    def _config_layer_udp(self, pkt_layer, config):
> -        return self.pktgen.udp(pkt_layer, **config)
> -
> -    def _config_layer_tcp(self, pkt_layer, config):
> -        return self.pktgen.tcp(pkt_layer, **config)
> -
> -    def _config_layer_sctp(self, pkt_layer, config):
> -        return self.pktgen.sctp(pkt_layer, **config)
> -
> -    def _config_layer_gre(self, pkt_layer, config):
> -        return self.pktgen.gre(pkt_layer, **config)
> -
> -    def _config_layer_raw(self, pkt_layer, config):
> -        return self.pktgen.raw(pkt_layer, **config)
> -
> -    def _config_layer_vxlan(self, pkt_layer, config):
> -        return self.pktgen.vxlan(pkt_layer, **config)
> -
> -    def strip_layer_element(self, layer, element):
> +    def strip_layer_element(self, layer, element, p_index=0):
>          """
>          Strip packet layer elements
>          return the status of configure result
>          """
>          strip_element = getattr(self, "strip_element_%s" % layer)
> +        return strip_element(element, p_index)
> 
> -        return strip_element(element)
> -
> -    def strip_element_layer2(self, element):
> -        return self.pktgen.strip_layer2(element)
> +    def strip_element_layer2(self, element, p_index=0):
> +        return self.pktgen.strip_layer2(element, p_index)
> 
> -    def strip_element_layer3(self, element):
> -        return self.pktgen.strip_layer3(element)
> +    def strip_element_layer3(self, element, p_index=0):
> +        return self.pktgen.strip_layer3(element, p_index)
> 
> -    def strip_element_vlan(self, element):
> -        return self.pktgen.strip_vlan(element)
> +    def strip_element_vlan(self, element, p_index=0):
> +        return self.pktgen.strip_vlan(element, p_index)
> 
> -    def strip_element_etag(self, element):
> -        return self.pktgen.strip_etag(element)
> +    def strip_element_etag(self, element, p_index=0):
> +        return self.pktgen.strip_etag(element, p_index)
> 
> -    def strip_element_layer4(self, element):
> -        return self.pktgen.strip_layer4(element)
> +    def strip_element_layer4(self, element, p_index=0):
> +        return self.pktgen.strip_layer4(element, p_index)
> 
> 
>  def IncreaseIP(addr):
> @@ -725,27 +836,6 @@ def IncreaseIPv6(addr):
>      return ipv6
> 
> 
> -def send_packets(intf, pkts=None, interval=0.01):
> -    send_pkts = []
> -    try:
> -        for pkt in pkts:
> -            send_pkts.append(pkt.pktgen.pkt)
> -        sendp(send_pkts, iface=intf, inter=interval, verbose=False)
> -    except:
> -        pass
> -
> -
> -def save_packets(pkts=None, filename=None):
> -    save_pkts = []
> -    try:
> -        for pkt in pkts:
> -            save_pkts.append(pkt.pktgen.pkt)
> -        if filename:
> -            wrpcap(filename, save_pkts)
> -    except:
> -        pass
> -
> -
>  def get_ether_type(eth_type=""):
>      # need add more types later
>      if eth_type.lower() == "lldp":
> @@ -809,48 +899,46 @@ def get_filter_cmd(filters=[]):
>          return ""
> 
> 
> -def sniff_packets(intf, count=0, timeout=5, filters=[], target=[]):
> +def start_tcpdump(crb, intf, count=0, filters=None, lldp_forbid=True):
>      """
> -    sniff all packets for certain port in certain seconds
> +    sniff all packets from certain port
>      """
> +    filters = [] if filters is None else filters
> +    out = crb.send_expect("ls -d %s" % crb.tmp_file, "# ", verify=True)
> +    if out == 2:
> +        crb.send_expect("mkdir -p %s" % crb.tmp_file, "# ")
> +    filename = '{}sniff_{}.pcap'.format(crb.tmp_file, intf)
> +    # delete old pcap file
> +    crb.send_expect('rm -rf %s' % filename, '# ')
> +
>      param = ""
>      direct_param = r"(\s+)\[ (\S+) in\|out\|inout \]"
> -
> -    try:
> -        tcpdump_help_session=pxssh.pxssh()
> -        tcpdump_help_session.login(server=target[0], username=target[1],
> -                                   password=target[2], original_prompt='[$#>]',
> -                                   login_timeout=20)
> -        tcpdump_help_session.sendline('tcpdump -h')
> -        tcpdump_help_session.prompt()
> -        tcpdump_help=tcpdump_help_session.before
> -        tcpdump_help_session.logout()
> -    except pxssh.ExceptionPxssh as e:
> -        print ('pxssh failed on login.')
> -        print (e)
> +    tcpdump_session = crb.create_session('tcpdump_session' + str(time.time()))
> +    setattr(tcpdump_session, 'tmp_file', crb.tmp_file)
> +    tcpdump_help = tcpdump_session.send_command('tcpdump -h')
> 
>      for line in tcpdump_help.split('\n'):
>          m = re.match(direct_param, line)
>          if m:
> -            opt = re.search("-Q", m.group(2));
> +            opt = re.search("-Q", m.group(2))
>              if opt:
>                  param = "-Q" + " in"
>              else:
> -                opt = re.search("-P", m.group(2));
> +                opt = re.search("-P", m.group(2))
>                  if opt:
>                      param = "-P" + " in"
> 
>      if len(param) == 0:
>          print "tcpdump not support direction choice!!!"
> 
> -    if LLDP_FILTER not in filters:
> +    if lldp_forbid and (LLDP_FILTER not in filters):
>          filters.append(LLDP_FILTER)
> 
>      filter_cmd = get_filter_cmd(filters)
> 
>      sniff_cmd = 'tcpdump -i %(INTF)s %(FILTER)s %(IN_PARAM)s -w %(FILE)s'
>      options = {'INTF': intf, 'COUNT': count, 'IN_PARAM': param,
> -               'FILE': '/tmp/sniff_%s.pcap' % intf,
> +               'FILE': filename,
>                 'FILTER': filter_cmd}
>      if count:
>          sniff_cmd += ' -c %(COUNT)d'
> @@ -858,77 +946,27 @@ def sniff_packets(intf, count=0, timeout=5, filters=[],
> target=[]):
>      else:
>          cmd = sniff_cmd % options
> 
> -    try:
> -        tcpdump_session=pxssh.pxssh()
> -        tcpdump_session.login(server=target[0], username=target[1],
> -                              password=target[2], original_prompt='[$#>]',
> -                              login_timeout=20)
> -        tcpdump_session.sendline(cmd)
> -        pipe = tcpdump_session
> -    except pxssh.ExceptionPxssh as e:
> -        print ('pxssh failed on login.')
> -        print (e)
> +    tcpdump_session.send_command(cmd)
> 
>      index = str(time.time())
> -    SNIFF_PIDS[index] = (pipe, intf, timeout)
> +    SNIFF_PIDS[index] = (tcpdump_session, intf, filename)
>      time.sleep(1)
>      return index
> 
> 
> -def load_sniff_pcap(index='', target=[]):
> +def stop_and_load_tcpdump_packets(index='', timeout=1):
>      """
> -    Stop sniffer and return pcap file
> +    Stop sniffer and return packet object
>      """
> -    child_exit = False
>      if index in SNIFF_PIDS.keys():
> -        pipe, intf, timeout = SNIFF_PIDS[index]
> -        time_elapse = int(time.time() - float(index))
> -        while time_elapse < timeout:
> -            if pipe.prompt(timeout=1):
> -                child_exit = True
> -                break
> -
> -            time_elapse += 1
> -
> -        if not child_exit:
> -            try:
> -                # Stop Tcpdump on the target server
> -                tcpdump_quit_session=pxssh.pxssh()
> -                tcpdump_quit_session.login(server=target[0], username=target[1],
> -                                           password=target[2], original_prompt='[$#>]',
> -                                           login_timeout=20)
> -                tcpdump_quit_session.sendline('kill -2 $(pidof tcpdump)')
> -                tcpdump_quit_session.prompt()
> -                tcpdump_quit_session.logout()
> -                child_exit = True
> -            except pxssh.ExceptionPxssh as e:
> -                print ('pxssh failed on login.')
> -                print (e)
> -
> -        # Close the Tcpdump_session
> -        pipe.prompt()
> -        pipe.logout()
> -
> -        # wait pcap file ready
> -        time.sleep(1)
> -        return "/tmp/sniff_%s.pcap" % intf
> -
> -    return ""
> -
> -
> -def load_pcapfile(filename=""):
> -    pkts = []
> -    try:
> -        cap_pkts = rdpcap(filename)
> -        for pkt in cap_pkts:
> -            # packet gen should be scapy
> -            packet = Packet()
> -            packet.pktgen.assign_pkt(pkt)
> -            pkts.append(packet)
> -    except:
> -        pass
> -
> -    return pkts
> +        pipe, intf, filename = SNIFF_PIDS.pop(index)
> +        pipe.get_session_before(timeout)
> +        pipe.send_command('^C')
> +        pipe.copy_file_from(filename, TMP_PATH)
> +        p = Packet()
> +        p.read_pcapfile(TMP_PATH + filename.split(os.sep)[-1])
> +        pipe.close()
> +        return p
> 
> 
>  def compare_pktload(pkt1=None, pkt2=None, layer="L2"):
> @@ -940,8 +978,8 @@ def compare_pktload(pkt1=None, pkt2=None, layer="L2"):
>      elif layer == "L4":
>          l_idx = 2
>      try:
> -        load1 = hexstr(str(pkt1.pktgen.pkt.getlayer(l_idx)))
> -        load2 = hexstr(str(pkt2.pktgen.pkt.getlayer(l_idx)))
> +        load1 = hexstr(str(pkt1.getlayer(l_idx)))
> +        load2 = hexstr(str(pkt2.getlayer(l_idx)))
>      except:
>          # return pass when scapy failed to extract packet
>          return True
> @@ -952,7 +990,7 @@ def compare_pktload(pkt1=None, pkt2=None, layer="L2"):
>          return False
> 
> 
> -def strip_pktload(pkt=None, layer="L2"):
> +def strip_pktload(pkt=None, layer="L2", p_index=0):
>      if layer == "L2":
>          l_idx = 0
>      elif layer == "L3":
> @@ -962,30 +1000,36 @@ def strip_pktload(pkt=None, layer="L2"):
>      else:
>          l_idx = 0
>      try:
> -        load = hexstr(str(pkt.pktgen.pkt.getlayer(l_idx)), onlyhex=1)
> +        load = hexstr(str(pkt.pktgen.pkts[p_index].getlayer(l_idx)),
> + onlyhex=1)
>      except:
>          # return pass when scapy failed to extract packet
>          load = ""
> 
>      return load
> 
> +
> 
> ###########################################################
> ####################
> 
> ###########################################################
> ####################
>  if __name__ == "__main__":
> -    pkt = Packet(pkt_type='UDP')
> -    pkt.send_pkt(tx_port='lo')
> +
> +    pkt =
> Packet('Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x0,NSP=0x000002,NSI=0xff
> )')
> +    sendp(pkt, iface='lo')
> +    pkt.config_layer('ipv4', {'dst': '192.168.8.8'})
> +    pkt.append_pkt(pkt_type='IPv6_TCP', pkt_len=100)
> +    pkt.append_pkt(pkt_type='TCP', pkt_len=100)
> +    pkt.config_layer('tcp', config={'flags': 'A'})
> +
> pkt.append_pkt("Ether(dst='11:22:33:44:55:11')/IP(dst='192.168.5.2')/TCP(flags=
> 0)/Raw(load='bbbb')")
> +    pkt.generate_random_pkts('11:22:33:44:55:55', random_type=['TCP', 'IPv6_TCP'],
> random_payload=True, pktnum=10)
> +    sendp(pkt, iface='lo')
> 
>      pkt = Packet(pkt_type='UDP', pkt_len=1500, ran_payload=True)
> -    pkt.send_pkt(tx_port='lo')
> -    pkt = Packet(pkt_type='IPv6_TCP')
> -    pkt.send_pkt(tx_port='lo')
> +    sendp(pkt, iface='lo')
>      pkt = Packet(pkt_type='IPv6_SCTP')
> -    pkt.send_pkt(tx_port='lo')
> +    sendp(pkt, iface='lo')
>      pkt = Packet(pkt_type='VLAN_UDP')
>      pkt.config_layer('vlan', {'vlan': 2})
> -    pkt.send_pkt(tx_port='lo')
> +    sendp(pkt, iface='lo')
> 
> -    pkt = Packet()
>      pkt.assign_layers(['ether', 'vlan', 'ipv4', 'udp',
>                         'vxlan', 'inner_mac', 'inner_ipv4', 'inner_udp', 'raw'])
>      pkt.config_layer('ether', {'dst': '00:11:22:33:44:55'}) @@ -994,13 +1038,12 @@ if
> __name__ == "__main__":
>      pkt.config_layer('udp', {'src': 4789, 'dst': 4789, 'chksum': 0x1111})
>      pkt.config_layer('vxlan', {'vni': 2})
>      pkt.config_layer('raw', {'payload': ['58'] * 18})
> -    pkt.send_pkt(tx_port='lo')
> +    sendp(pkt, iface='lo')
> 
> -    pkt = Packet()
>      pkt.assign_layers(['ether', 'vlan', 'ipv4', 'udp',
>                         'vxlan', 'inner_mac', 'inner_ipv4', 'inner_udp', 'raw'])
>      # config packet
>      pkt.config_layers([('ether', {'dst': '00:11:22:33:44:55'}), ('ipv4', {'dst': '1.1.1.1'}),
>                         ('vxlan', {'vni': 2}), ('raw', {'payload': ['01'] * 18})])
> 
> -    pkt.send_pkt(tx_port='lo')
> +    sendp(pkt, iface='lo')
> --
> 2.17.1