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(
  33             str(netaddr.IPAddress(base) + random.randint(0, (n - 1) * increment))
  34         )
  35     return eids
  36
  37
  38 def generate_eids_sequential(base, n):
  39     """Generate n number of EIDs in sequential order starting from base
  40     Args:
  41         :param base: A string used as the first EID
  42         :param n: An integer, number of EIDs to generate
  43     Returns:
  44         :return : returns list containing string EIDs
  45     """
  46     eids = []
  47     for i in range(0, n):
  48         eids.append(str(netaddr.IPAddress(base) + i * increment))
  49     return eids
  50
  51
  52 def generate_map_request(eid):
  53     """Create a LISP Map-Request packet as a Scapy object
  54     Args:
  55         :param eid: A string used as the EID record
  56     Returns:
  57         :return : returns a Scapy Map-Request packet object
  58     """
  59     sport1 = random.randint(60000, 65000)
  60     sport2 = random.randint(60000, 65000)
  61     rnonce = random.randint(0, 2**63)
  62
  63     itr_rloc = [lisp.LISP_AFI_Address(address=src_rloc, afi=1)]
  64     record = [
  65         lisp.LISP_MapRequestRecord(request_address=eid, request_afi=1, eid_mask_len=32)
  66     ]
  67
  68     packet = lisp.Ether(dst=dst_mac, src=src_mac)
  69     packet /= lisp.IP(dst=dst_rloc, src=src_rloc)
  70     packet /= lisp.UDP(sport=sport1, dport=4342)
  71     packet /= lisp.LISP_Encapsulated_Control_Message(ptype=8)
  72     packet /= lisp.IP(dst=eid, src=src_eid)
  73     packet /= lisp.UDP(sport=sport2, dport=4342)
  74     packet /= lisp.LISP_MapRequest(
  75         nonce=rnonce,
  76         request_afi=1,
  77         address=src_eid,
  78         ptype=1,
  79         itr_rloc_records=itr_rloc,
  80         request_records=record,
  81     )
  82     return packet
  83
  84
  85 def generate_map_register(eid, rloc, key_id):
  86     """Create a LISP Map-Register packet as a Scapy object
  87     Args:
  88         :param eid: A string used as the EID record
  89         :param rloc: A string used as the RLOC
  90         :param key_id: Integer value specifying the authentication type
  91     Returns:
  92         :return : returns a Scapy Map-Request packet object
  93     """
  94     sport1 = random.randint(60000, 65000)
  95     rnonce = random.randint(0, 2**63)
  96
  97     rlocs = [
  98         lisp.LISP_Locator_Record(
  99             priority=1,
 100             weight=1,
 101             multicast_priority=255,
 102             multicast_weight=0,
 103             reserved=0,
 104             locator_flags=5,
 105             locator_afi=1,
 106             address=rloc,
 107         )
 108     ]
 109
 110     record = [
 111         lisp.LISP_MapRecord(
 112             record_ttl=1440,
 113             locator_count=1,
 114             eid_prefix_length=32,
 115             action=0,
 116             authoritative=1,
 117             reserved=0,
 118             map_version_number=0,
 119             record_afi=1,
 120             record_address=eid,
 121             locators=rlocs,
 122         )
 123     ]
 124
 125     packet = lisp.Ether(dst=dst_mac, src=src_mac)
 126     packet /= lisp.IP(dst=dst_rloc, src=src_rloc)
 127     packet /= lisp.UDP(sport=sport1, dport=4342)
 128     packet /= lisp.LISP_MapRegister(
 129         ptype=3,
 130         nonce=rnonce,
 131         register_flags=10,
 132         additional_register_flags=1,
 133         register_count=1,
 134         key_id=key_id,
 135         register_records=record,
 136         xtr_id_low=netaddr.IPAddress(eid),
 137     )
 138     return packet
 139
 140
 141 parser = argparse.ArgumentParser(description="Create a Map-Request trace file")
 142
 143 parser.add_argument(
 144     "--dst-mac",
 145     default="00:00:00:00:00:00",
 146     help="Map-Request destination MAC address \
 147                         (default is 00:00:00:00:00:00)",
 148 )
 149 parser.add_argument(
 150     "--src-mac",
 151     default="00:00:00:00:00:00",
 152     help="Map-Request source MAC address \
 153                         (default is 00:00:00:00:00:00)",
 154 )
 155 parser.add_argument(
 156     "--dst-rloc",
 157     default="127.0.0.1",
 158     help="Send Map-Request to the Map-Server with this RLOC \
 159                         (default is 127.0.0.1)",
 160 )
 161 parser.add_argument(
 162     "--src-rloc",
 163     default="127.0.0.1",
 164     help="Send Map-Request with this source RLOC \
 165                         (default is 127.0.0.1)",
 166 )
 167 parser.add_argument(
 168     "--src-eid",
 169     default="192.0.2.1",
 170     help="Send Map-Request with this source EID \
 171                         (default is 192.0.2.1)",
 172 )
 173 parser.add_argument(
 174     "--base-eid",
 175     default="10.0.0.0",
 176     help="Start incrementing EID from this address \
 177                         (default is 10.0.0.0)",
 178 )
 179 parser.add_argument(
 180     "--requests", type=int, default=1, help="Number of requests to create (default 1)"
 181 )
 182 parser.add_argument(
 183     "--increment", type=int, default=1, help="Increment EID requests (default 1)"
 184 )
 185 parser.add_argument(
 186     "--random",
 187     type=bool,
 188     default=False,
 189     help="Create random EID requests (default False)",
 190 )
 191
 192 in_args = parser.parse_args()
 193 dst_mac = in_args.dst_mac
 194 src_mac = in_args.src_mac
 195 dst_rloc = in_args.dst_rloc
 196 src_rloc = in_args.src_rloc
 197 src_eid = in_args.src_eid
 198 increment = in_args.increment
 199
 200 seq_eids = generate_eids_sequential(in_args.base_eid, in_args.requests)
 201 seq_pkts_mreq = []
 202 seq_pkts_mreg = []
 203 seq_pkts_mrga = []
 204
 205 for eid in seq_eids:
 206     seq_pkts_mreq.append(generate_map_request(eid))
 207     seq_pkts_mreg.append(generate_map_register(eid, eid, 0))
 208     seq_pkts_mrga.append(generate_map_register(eid, eid, 1))
 209
 210 lisp.wrpcap("encapsulated-map-requests-sequential.pcap", seq_pkts_mreq)
 211 lisp.wrpcap("map-registers-sequential-no-auth.pcap", seq_pkts_mreg)
 212 lisp.wrpcap("map-registers-sequential-sha1-auth.pcap", seq_pkts_mrga)
 213
 214 if in_args.random is True:
 215     rand_eids = generate_eids_random(in_args.base_eid, in_args.requests)
 216     rand_pkts_mreq = []
 217     rand_pkts_mreg = []
 218     rand_pkts_mrga = []
 219
 220     for eid in rand_eids:
 221         rand_pkts_mreq.append(generate_map_request(eid))
 222         rand_pkts_mreg.append(generate_map_register(eid, eid, 0))
 223         rand_pkts_mrga.append(generate_map_register(eid, eid, 1))
 224
 225     lisp.wrpcap("encapsulated-map-requests-random.pcap", rand_pkts_mreq)
 226     lisp.wrpcap("map-registers-random-no-auth.pcap", rand_pkts_mreg)
 227     lisp.wrpcap("map-registers-random-sha1-auth.pcap", rand_pkts_mreg)