aboutsummaryrefslogtreecommitdiffstats
path: root/resources/traffic_profiles/trex/trex-sl-2n-ethip4-ip4dst-rnd10000.py
blob: 4ad4de5a3b656d0bfd9a2297eb4c5dae08d389f8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
# Copyright (c) 2019 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Stream profile for T-rex traffic generator.

Stream profile:
 - Two streams sent in directions 0 --> 1 and 1 --> 0 at the same time.
 - Packet: ETH / IP /
 - Direction 0 --> 1:
   - Source IP address range:      10.0.0.1
   - Destination IP address range: 20.0.0.0 - 20.0.39.15
 - Direction 1 --> 0:
   - Source IP address range:      20.0.0.1
   - Destination IP address range: 10.0.0.0 - 10.0.39.15
"""

from trex.stl.api import *
from profile_trex_stateless_base_class import TrafficStreamsBaseClass


class TrafficStreams(TrafficStreamsBaseClass):
    """Stream profile."""

    def __init__(self):
        """Initialization and setting of streams" parameters."""

        super(TrafficStreamsBaseClass, self).__init__()

        # IPs used in packet headers.
        self.p1_src_start_ip = u"10.0.0.1"
        self.p1_dst_start_ip = u"20.0.0.0"
        self.p1_dst_end_ip = u"20.0.39.15"

        self.p2_src_start_ip = u"20.0.0.1"
        self.p2_dst_start_ip = u"10.0.0.0"
        self.p2_dst_end_ip = u"10.0.39.15"

    def define_packets(self):
        """Defines the packets to be sent from the traffic generator.

        Packet definition: | ETH | IP |

        :returns: Packets to be sent from the traffic generator.
        :rtype: tuple
        """

        # Direction 0 --> 1
        base_pkt_a = (Ether() /
                      IP(src=self.p1_src_start_ip,
                         dst=self.p1_dst_start_ip,
                         proto=61))
        # Direction 1 --> 0
        base_pkt_b = (Ether() /
                      IP(src=self.p2_src_start_ip,
                         dst=self.p2_dst_start_ip,
                         proto=61))

        # Direction 0 --> 1
        vm1 = STLScVmRaw([STLVmFlowVarRepeatableRandom (\
                              name=u"dst",
                              min_value=self.p1_dst_start_ip,
                              max_value=self.p1_dst_end_ip,
                              size=4,
                              limit=10000, seed=0x0000),
                          STLVmWrFlowVar(\
                              fv_name=u"dst", pkt_offset=u"IP.dst"),
                          STLVmFixIpv4(offset=u"IP")])
        # Direction 1 --> 0
        vm2 = STLScVmRaw([STLVmFlowVarRepeatableRandom (name=u"dst",
                              min_value=self.p2_dst_start_ip,
                              max_value=self.p2_dst_end_ip,
                              size=4,
                              limit=10000, seed=0x0000),
                          STLVmWrFlowVar(fv_name=u"dst", pkt_offset=u"IP.dst"),
                          STLVmFixIpv4(offset=u"IP")])

        return base_pkt_a, base_pkt_b, vm1, vm2


def register():
    """Register this traffic profile to T-rex.

    Do not change this function.

    :return: Traffic streams.
    :rtype: Object
    """
    return TrafficStreams()
ort ETH_P_IP, ETH_P_IPV6, ETH_P_ALL, ETH_P_ARP from scapy.all import Ether, ARP, Packet from scapy.layers.inet6 import IPv6 __all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request', 'auto_pad'] # TODO: http://stackoverflow.com/questions/320232/ensuring-subprocesses-are-dead-on-exiting-python-program class PacketVerifier(object): """Base class for TX and RX queue objects for packet verifier.""" def __init__(self, interface_name): os.system('sudo echo 1 > /proc/sys/net/ipv6/conf/{0}/disable_ipv6' .format(interface_name)) os.system('sudo ip link set {0} up promisc on'.format(interface_name)) self._sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL) self._sock.bind((interface_name, ETH_P_ALL)) self._ifname = interface_name def extract_one_packet(buf): """Extract one packet from the incoming buf buffer. Takes string as input and looks for first whole packet in it. If it finds one, it returns substring from the buf parameter. :param buf: string representation of incoming packet buffer. :type buf: string :return: String representation of first packet in buf. :rtype: string """ pkt_len = 0 if len(buf) < 60: return None # print # print buf.__repr__() # print Ether(buf).__repr__() # print len(Ether(buf)) # print try: ether_type = Ether(buf[0:14]).type except AttributeError: raise RuntimeError( 'No EtherType in packet {0}'.format(buf.__repr__())) if ether_type == ETH_P_IP: # 14 is Ethernet fame header size. # 4 bytes is just enough to look for length in ip header. # ip total length contains just the IP packet length so add the Ether # header. pkt_len = Ether(buf[0:14+4]).len + 14 if len(buf) < 60: return None elif ether_type == ETH_P_IPV6: if not Ether(buf[0:14+6]).haslayer(IPv6): raise RuntimeError( 'Invalid IPv6 packet {0}'.format(buf.__repr__())) # ... to add to the above, 40 bytes is the length of IPV6 header. # The ipv6.len only contains length of the payload and not the header pkt_len = Ether(buf)['IPv6'].plen + 14 + 40 if len(buf) < 60: return None elif ether_type == ETH_P_ARP: pkt = Ether(buf[:20]) if not pkt.haslayer(ARP): raise RuntimeError('Incomplete ARP packet') # len(eth) + arp(2 hw addr type + 2 proto addr type # + 1b len + 1b len + 2b operation) pkt_len = 14 + 8 pkt_len += 2 * pkt.getlayer(ARP).hwlen pkt_len += 2 * pkt.getlayer(ARP).plen del pkt elif ether_type == 32821: # RARP (Reverse ARP) pkt = Ether(buf[:20]) pkt.type = ETH_P_ARP # Change to ARP so it works with scapy pkt = Ether(str(pkt)) if not pkt.haslayer(ARP): pkt.show() raise RuntimeError('Incomplete RARP packet') # len(eth) + arp(2 hw addr type + 2 proto addr type # + 1b len + 1b len + 2b operation) pkt_len = 14 + 8 pkt_len += 2 * pkt.getlayer(ARP).hwlen pkt_len += 2 * pkt.getlayer(ARP).plen del pkt else: raise RuntimeError('Unknown protocol {0}'.format(ether_type)) if pkt_len < 60: pkt_len = 60 if len(buf) < pkt_len: return None return buf[0:pkt_len] def packet_reader(interface_name, queue): """Sub-process routine that reads packets and puts them to queue. This function is meant to be run in separate subprocess and is in tight loop reading raw packets from interface passed as parameter. :param interace_name: Name of interface to read packets from. :param queue: Queue in which this function will push incoming packets. :type interface_name: string :type queue: multiprocessing.Queue :return: None """ sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL) sock.bind((interface_name, ETH_P_ALL)) while True: pkt = sock.recv(0x7fff) queue.put(pkt) class RxQueue(PacketVerifier): """Receive queue object. This object creates raw socket, reads packets from it and provides function to access them. :param interface_name: Which interface to bind to. :type interface_name: string """ def __init__(self, interface_name): PacketVerifier.__init__(self, interface_name) #self._queue = Queue() #self._proc = Process(target=packet_reader, args=(interface_name, # self._queue)) #self._proc.daemon = True #self._proc.start() #time.sleep(2) def recv(self, timeout=3, ignore=None): """Read next received packet. Returns scapy's Ether() object created from next packet in the queue. Queue is being filled in parallel in subprocess. If no packet arrives in given timeout queue.Empty exception will be risen. :param timeout: How many seconds to wait for next packet. :type timeout: int :return: Ether() initialized object from packet data. :rtype: scapy.Ether """ #pkt = self._queue.get(True, timeout=timeout) (rlist, _, _) = select.select([self._sock], [], [], timeout) if self._sock not in rlist: return None pkt = self._sock.recv(0x7fff) print 'Received packet on {0} of len {1}'.format(self._ifname, len(pkt)) Ether(pkt).show2() print if ignore is not None: for i, ig_pkt in enumerate(ignore): # Auto pad all packets in ignore list ignore[i] = auto_pad(ig_pkt) for ig_pkt in ignore: if ig_pkt == pkt: # Found the packet in ignore list, get another one # TODO: subtract timeout - time_spent in here ignore.remove(ig_pkt) return self.recv(timeout, ignore) return Ether(pkt) class TxQueue(PacketVerifier): """Transmission queue object. This object is used to send packets over RAW socket on a interface. :param interface_name: Which interface to send packets from. :type interface_name: string """ def __init__(self, interface_name): PacketVerifier.__init__(self, interface_name) def send(self, pkt): """Send packet out of the bound interface. :param pkt: Packet to send. :type pkt: string or scapy Packet derivative. """ print 'Sending packet out of {0} of len {1}'.format(self._ifname, len(pkt)) Ether(str(pkt)).show2() print pkt = auto_pad(str(pkt)) self._sock.send(pkt) class Interface(object): def __init__(self, if_name): self.if_name = if_name self.sent_packets = [] self.rxq = RxQueue(if_name) self.txq = TxQueue(if_name) def send_pkt(self, pkt): self.sent_packets.append(pkt) self.txq.send(pkt) def recv_pkt(self, timeout=3): return self.rxq.recv(timeout, self.sent_packets) def close(self): #self.rxq._proc.terminate() pass def create_gratuitous_arp_request(src_mac, src_ip): """Creates scapy representation of gratuitous ARP request""" return (Ether(src=src_mac, dst='ff:ff:ff:ff:ff:ff') / ARP(psrc=src_ip, hwsrc=src_mac, pdst=src_ip)) def auto_pad(packet): """Pads zeroes at the end of the packet if the total len < 60 bytes.""" padded = str(packet) if len(padded) < 60: padded += ('\0' * (60 - len(padded))) return padded