tools/odl-lispflowmapping-performance-tests/create_lisp_control_plane_pcap.py

   1 #!/usr/bin/env python
   2 """
   3 Script to generate files with n Map-Request packets and n Map-Register packets
   4 with EID records increasing sequentially and (optionally) files with n
   5 Map-Request packets and n Map-Register packets that have random EIDs
   6
   7 Use `./create_lisp_control_plane_pcap.py --help` to see options
   8 """
   9
  10 import argparse
  11 import netaddr
  12 import lisp
  13 import random
  14
  15 __author__ = "Lori Jakab"
  16 __copyright__ = "Copyright (c) 2015, Cisco Systems, Inc."
  17 __license__ = "New-style BSD"
  18 __email__ = "lojakab@cisco.com"
  19 __version__ = "0.0.3"
  20
  21
  22 def generate_eids_random(base, n):
  23     """Generate n number of EIDs in random order starting from base
  24     Args:
  25         :param base: A string used as the first EID
  26         :param n: An integer, number of EIDs to generate
  27     Returns:
  28         :return : returns list containing string EIDs
  29     """
  30     eids = []
  31     for i in range(0, n):
  32         eids.append(str(netaddr.IPAddress(base) +
  33                         random.randint(0, (n - 1) * increment)))
  34     return eids
  35
  36
  37 def generate_eids_sequential(base, n):
  38     """Generate n number of EIDs in sequential order starting from base
  39     Args:
  40         :param base: A string used as the first EID
  41         :param n: An integer, number of EIDs to generate
  42     Returns:
  43         :return : returns list containing string EIDs
  44     """
  45     eids = []
  46     for i in range(0, n):
  47         eids.append(str(netaddr.IPAddress(base) + i * increment))
  48     return eids
  49
  50
  51 def generate_map_request(eid):
  52     """Create a LISP Map-Request packet as a Scapy object
  53     Args:
  54         :param eid: A string used as the EID record
  55     Returns:
  56         :return : returns a Scapy Map-Request packet object
  57     """
  58     sport1 = random.randint(60000, 65000)
  59     sport2 = random.randint(60000, 65000)
  60     rnonce = random.randint(0, 2**63)
  61
  62     itr_rloc = [lisp.LISP_AFI_Address(address=src_rloc, afi=1)]
  63     record = [lisp.LISP_MapRequestRecord(request_address=eid,
  64                                          request_afi=1,
  65                                          eid_mask_len=32)]
  66
  67     packet = lisp.Ether(dst=dst_mac, src=src_mac)
  68     packet /= lisp.IP(dst=dst_rloc, src=src_rloc)
  69     packet /= lisp.UDP(sport=sport1, dport=4342)
  70     packet /= lisp.LISP_Encapsulated_Control_Message(ptype=8)
  71     packet /= lisp.IP(dst=eid, src=src_eid)
  72     packet /= lisp.UDP(sport=sport2, dport=4342)
  73     packet /= lisp.LISP_MapRequest(nonce=rnonce, request_afi=1,
  74                                    address=src_eid, ptype=1,
  75                                    itr_rloc_records=itr_rloc,
  76                                    request_records=record)
  77     return packet
  78
  79
  80 def generate_map_register(eid, rloc, key_id):
  81     """Create a LISP Map-Register packet as a Scapy object
  82     Args:
  83         :param eid: A string used as the EID record
  84         :param rloc: A string used as the RLOC
  85         :param key_id: Integer value specifying the authentication type
  86     Returns:
  87         :return : returns a Scapy Map-Request packet object
  88     """
  89     sport1 = random.randint(60000, 65000)
  90     rnonce = random.randint(0, 2**63)
  91
  92     rlocs = [lisp.LISP_Locator_Record(priority=1, weight=1,
  93                                       multicast_priority=255,
  94                                       multicast_weight=0,
  95                                       reserved=0, locator_flags=5,
  96                                       locator_afi=1, address=rloc)]
  97
  98     record = [lisp.LISP_MapRecord(record_ttl=1440, locator_count=1,
  99                                   eid_prefix_length=32, action=0,
 100                                   authoritative=1, reserved=0,
 101                                   map_version_number=0, record_afi=1,
 102                                   record_address=eid, locators=rlocs)]
 103
 104     packet = lisp.Ether(dst=dst_mac, src=src_mac)
 105     packet /= lisp.IP(dst=dst_rloc, src=src_rloc)
 106     packet /= lisp.UDP(sport=sport1, dport=4342)
 107     packet /= lisp.LISP_MapRegister(ptype=3, nonce=rnonce,
 108                                     register_flags=10,
 109                                     additional_register_flags=1,
 110                                     register_count=1,
 111                                     key_id=key_id,
 112                                     register_records=record,
 113                                     xtr_id_low=netaddr.IPAddress(eid))
 114     return packet
 115
 116
 117 parser = argparse.ArgumentParser(description='Create a Map-Request trace file')
 118
 119 parser.add_argument('--dst-mac', default='00:00:00:00:00:00',
 120                     help='Map-Request destination MAC address \
 121                         (default is 00:00:00:00:00:00)')
 122 parser.add_argument('--src-mac', default='00:00:00:00:00:00',
 123                     help='Map-Request source MAC address \
 124                         (default is 00:00:00:00:00:00)')
 125 parser.add_argument('--dst-rloc', default='127.0.0.1',
 126                     help='Send Map-Request to the Map-Server with this RLOC \
 127                         (default is 127.0.0.1)')
 128 parser.add_argument('--src-rloc', default='127.0.0.1',
 129                     help='Send Map-Request with this source RLOC \
 130                         (default is 127.0.0.1)')
 131 parser.add_argument('--src-eid', default='192.0.2.1',
 132                     help='Send Map-Request with this source EID \
 133                         (default is 192.0.2.1)')
 134 parser.add_argument('--base-eid', default='10.0.0.0',
 135                     help='Start incrementing EID from this address \
 136                         (default is 10.0.0.0)')
 137 parser.add_argument('--requests', type=int, default=1,
 138                     help='Number of requests to create (default 1)')
 139 parser.add_argument('--increment', type=int, default=1,
 140                     help='Increment EID requests (default 1)')
 141 parser.add_argument('--random', type=bool, default=False,
 142                     help='Create random EID requests (default False)')
 143
 144 in_args = parser.parse_args()
 145 dst_mac = in_args.dst_mac
 146 src_mac = in_args.src_mac
 147 dst_rloc = in_args.dst_rloc
 148 src_rloc = in_args.src_rloc
 149 src_eid = in_args.src_eid
 150 increment = in_args.increment
 151
 152 seq_eids = generate_eids_sequential(in_args.base_eid, in_args.requests)
 153 seq_pkts_mreq = []
 154 seq_pkts_mreg = []
 155 seq_pkts_mrga = []
 156
 157 for eid in seq_eids:
 158     seq_pkts_mreq.append(generate_map_request(eid))
 159     seq_pkts_mreg.append(generate_map_register(eid, eid, 0))
 160     seq_pkts_mrga.append(generate_map_register(eid, eid, 1))
 161
 162 lisp.wrpcap("encapsulated-map-requests-sequential.pcap", seq_pkts_mreq)
 163 lisp.wrpcap("map-registers-sequential-no-auth.pcap", seq_pkts_mreg)
 164 lisp.wrpcap("map-registers-sequential-sha1-auth.pcap", seq_pkts_mrga)
 165
 166 if in_args.random is True:
 167     rand_eids = generate_eids_random(in_args.base_eid, in_args.requests)
 168     rand_pkts_mreq = []
 169     rand_pkts_mreg = []
 170     rand_pkts_mrga = []
 171
 172     for eid in rand_eids:
 173         rand_pkts_mreq.append(generate_map_request(eid))
 174         rand_pkts_mreg.append(generate_map_register(eid, eid, 0))
 175         rand_pkts_mrga.append(generate_map_register(eid, eid, 1))
 176
 177     lisp.wrpcap("encapsulated-map-requests-random.pcap", rand_pkts_mreq)
 178     lisp.wrpcap("map-registers-random-no-auth.pcap", rand_pkts_mreg)
 179     lisp.wrpcap("map-registers-random-sha1-auth.pcap", rand_pkts_mreg)