resources/libraries/python/Map.py

   1 # Copyright (c) 2016 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """Map utilities library."""
  15
  16
  17 import ipaddress
  18
  19 from resources.libraries.python.VatExecutor import VatExecutor
  20
  21
  22 class Map(object):
  23     """Utilities for manipulating MAP feature in VPP."""
  24
  25     @staticmethod
  26     def map_add_domain(vpp_node, ip4_pfx, ip6_pfx, ip6_src, ea_bits_len,
  27                        psid_offset, psid_len, map_t=False):
  28         """Add map domain on node.
  29
  30         :param vpp_node: VPP node to add map domain on.
  31         :param ip4_pfx: Rule IPv4 prefix.
  32         :param ip6_pfx: Rule IPv6 prefix.
  33         :param ip6_src: MAP domain IPv6 BR address / Tunnel source.
  34         :param ea_bits_len: Embedded Address bits length.
  35         :param psid_offset: Port Set Identifier (PSID) offset.
  36         :param psid_len: Port Set Identifier (PSID) length.
  37         :param map_t: Mapping using translation instead of encapsulation.
  38         Default False.
  39         :type vpp_node: dict
  40         :type ip4_pfx: str
  41         :type ip6_pfx: str
  42         :type ip6_src: str
  43         :type ea_bits_len: int
  44         :type psid_offset: int
  45         :type psid_len: int
  46         :type map_t: bool
  47         :returns: Index of created map domain.
  48         :rtype: int
  49         :raises RuntimeError: If unable to add map domain.
  50         """
  51         translate = 'map-t' if map_t else ''
  52
  53         output = VatExecutor.cmd_from_template(vpp_node, "map_add_domain.vat",
  54                                                ip4_pfx=ip4_pfx,
  55                                                ip6_pfx=ip6_pfx,
  56                                                ip6_src=ip6_src,
  57                                                ea_bits_len=ea_bits_len,
  58                                                psid_offset=psid_offset,
  59                                                psid_len=psid_len,
  60                                                map_t=translate)
  61         if output[0]["retval"] == 0:
  62             return output[0]["index"]
  63         else:
  64             raise RuntimeError('Unable to add map domain on node {}'
  65                                .format(vpp_node['host']))
  66
  67     @staticmethod
  68     def map_add_rule(vpp_node, index, psid, dst, delete=False):
  69         """Add or delete map rule on node.
  70
  71         :param vpp_node: VPP node to add map rule on.
  72         :param index: Map domain index to add rule to.
  73         :param psid: Port Set Identifier.
  74         :param dst: MAP CE IPv6 address.
  75         :param delete: If set to True, delete rule. Default False.
  76         :type vpp_node: dict
  77         :type index: int
  78         :type psid: int
  79         :type dst: str
  80         :type delete: bool
  81         :raises RuntimeError: If unable to add map rule.
  82         """
  83         output = VatExecutor.cmd_from_template(vpp_node, "map_add_del_rule.vat",
  84                                                index=index,
  85                                                psid=psid,
  86                                                dst=dst,
  87                                                delete='del' if delete else '')
  88
  89         if output[0]["retval"] != 0:
  90             raise RuntimeError('Unable to add map rule on node {}'
  91                                .format(vpp_node['host']))
  92
  93     @staticmethod
  94     def map_del_domain(vpp_node, index):
  95         """Delete map domain on node.
  96
  97         :param vpp_node: VPP node to delete map domain on.
  98         :param index: Index of the map domain.
  99         :type vpp_node: dict
 100         :type index: int
 101         :raises RuntimeError: If unable to delete map domain.
 102         """
 103         output = VatExecutor.cmd_from_template(vpp_node, "map_del_domain.vat",
 104                                                index=index)
 105         if output[0]["retval"] != 0:
 106             raise RuntimeError('Unable to delete map domain {} on node {}'
 107                                .format(index, vpp_node['host']))
 108
 109     @staticmethod
 110     def get_psid_from_port(port, psid_len, psid_offset):
 111         """Return PSID from port.
 112                               0                   1
 113                               0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
 114                              +-----------+-----------+-------+
 115                Ports in      |     A     |    PSID   |   j   |
 116             the CE port set  |    > 0    |           |       |
 117                              +-----------+-----------+-------+
 118                              |  a bits   |  k bits   |m bits |
 119
 120
 121         :param port: Port to compute PSID from.
 122         :param psid_len: PSID length.
 123         :param psid_offset: PSID offset.
 124         :type port: int
 125         :type psid_len: int
 126         :type psid_offset: int
 127         :returns: PSID.
 128         :rtype: int
 129         """
 130         ones = 2**16-1
 131         mask = ones >> (16 - psid_len)
 132         psid = port >> (16 - psid_len - psid_offset)
 133         psid &= mask
 134         return psid
 135
 136     @staticmethod
 137     def _make_ea_bits(ipv4_net, ipv4_host, ea_bit_len, psid_len, psid):
 138         """
 139         _note_: host(or prefix) part of destination ip in rule prefix, + psid
 140
 141         :param ipv4_net: IPv4 domain prefix.
 142         :param ipv4_host: Destination IPv4 address.
 143         :param ea_bit_len: EA bit length.
 144         :param psid_len: PSID length.
 145         :param psid: PSID.
 146         :type ipv4_net: ipaddress.IPv4Network
 147         :type ipv4_host: ipaddress.IPv4Address
 148         :type ea_bit_len: int
 149         :type psid_len: int
 150         :type psid: int
 151         :returns: Number representing EA bit field of destination IPv6 address.
 152         :rtype: int
 153         """
 154         v4_suffix_len = ipv4_net.max_prefixlen - ipv4_net.prefixlen
 155         v4_suffix = ipv4_net.network_address._ip ^ ipv4_host._ip
 156
 157         if ipv4_net.prefixlen + ea_bit_len <= 32:
 158             ea_bits = v4_suffix >> (v4_suffix_len - ea_bit_len)
 159             return ea_bits
 160         else:
 161             q_len = ea_bit_len - v4_suffix_len
 162             # p_bits = v4_suffix << q_len  # option 1: psid right padded
 163             p_bits = v4_suffix << psid_len  # option 2: psid left padded
 164             if q_len < psid_len:
 165                 raise Exception("invalid configuration: q_len < psid_len")
 166             ea_bits = p_bits | psid
 167             ea_bits <<= q_len - psid_len  # option 2: psid left padded
 168             return ea_bits
 169
 170     @staticmethod
 171     def _make_interface_id(rule_net, dst_ip, ea_bit_len, psid):
 172         """
 173         _note_: if prefix or complete ip (<= 32), psid is 0
 174
 175         :param rule_net: IPv4 domain prefix.
 176         :param dst_ip: Destination IPv4 address.
 177         :param ea_bit_len: EA bit length.
 178         :param psid: PSID.
 179         :type rule_net: ipaddress.IPv4Network
 180         :type dst_ip: ipaddress.IPv4Address
 181         :type ea_bit_len: int
 182         :type psid: int
 183         :returns: Number representing interface id field of destination IPv6
 184         address.
 185         :rtype: int
 186         """
 187         if rule_net.prefixlen + ea_bit_len < 32:
 188             v4_suffix_len = rule_net.max_prefixlen - rule_net.prefixlen
 189             v4_suffix = rule_net.network_address._ip ^ dst_ip._ip
 190             ea_bits = v4_suffix >> (v4_suffix_len - ea_bit_len)
 191             address = rule_net.network_address._ip >> v4_suffix_len
 192             address <<= ea_bit_len
 193             address |= ea_bits
 194             address <<= 32 - rule_net.prefixlen - ea_bit_len
 195             address <<= 16
 196         elif rule_net.prefixlen + ea_bit_len == 32:
 197             address = dst_ip._ip << 16
 198         else:
 199             address = dst_ip._ip << 16
 200             address |= psid
 201             return address
 202
 203         return address
 204
 205     @staticmethod
 206     def compute_ipv6_map_destination_address(ipv4_pfx, ipv6_pfx, ea_bit_len,
 207                                              psid_offset, psid_len, ipv4_dst,
 208                                              dst_port):
 209         """Compute IPv6 destination address from IPv4 address for MAP algorithm.
 210         (RFC 7597)
 211
 212        |     n bits         |  o bits   | s bits  |   128-n-o-s bits      |
 213        +--------------------+-----------+---------+-----------------------+
 214        |  Rule IPv6 prefix  |  EA bits  |subnet ID|     interface ID      |
 215        +--------------------+-----------+---------+-----------------------+
 216        |<---  End-user IPv6 prefix  --->|
 217
 218
 219         :param ipv4_pfx: Domain IPv4 preffix.
 220         :param ipv6_pfx: Domain IPv6 preffix.
 221         :param ea_bit_len: Domain EA bits length.
 222         :param psid_offset: Domain PSID offset.
 223         :param psid_len: Domain PSID length.
 224         :param ipv4_dst: Destination IPv4 address.
 225         :param dst_port: Destination port number or ICMP ID.
 226         :type ipv4_pfx: str
 227         :type ipv6_pfx: str
 228         :type ea_bit_len: int
 229         :type psid_offset: int
 230         :type psid_len: int
 231         :type ipv4_dst: str
 232         :type dst_port: int
 233         :returns: Computed IPv6 address.
 234         :rtype: str
 235         """
 236         ipv6_net = ipaddress.ip_network(unicode(ipv6_pfx))
 237         ipv4_net = ipaddress.ip_network(unicode(ipv4_pfx))
 238         ipv4_host = ipaddress.ip_address(unicode(ipv4_dst))
 239
 240         ipv6_host_len = ipv6_net.max_prefixlen - ipv6_net.prefixlen
 241         end_user_v6_pfx_len = ipv6_net.prefixlen + ea_bit_len
 242         psid = Map.get_psid_from_port(dst_port, psid_len, psid_offset)
 243
 244         rule_v6_pfx = ipv6_net.network_address._ip >> ipv6_host_len
 245         ea_bits = Map._make_ea_bits(ipv4_net, ipv4_host, ea_bit_len, psid_len,
 246                                     psid)
 247         interface_id = Map._make_interface_id(ipv4_net, ipv4_host, ea_bit_len,
 248                                               psid)
 249
 250         address = rule_v6_pfx << ea_bit_len
 251         address |= ea_bits  # add EA bits
 252
 253         if end_user_v6_pfx_len > 64:
 254             # If the End-user IPv6 prefix length is larger than 64,
 255             # the most significant parts of the interface identifier are
 256             # overwritten by the prefix.
 257             mask = (2**128-1) >> end_user_v6_pfx_len
 258             interface_id &= mask
 259         address <<= (128 - end_user_v6_pfx_len)
 260         address |= interface_id  # add Interface ID bits
 261
 262         return str(ipaddress.ip_address(address))
 263
 264     @staticmethod
 265     def compute_ipv6_map_source_address(ipv6_pfx, ipv4_src):
 266         """Compute IPv6 source address from IPv4 address for MAP-T algorithm.
 267
 268         :param ipv6_pfx: 96 bit long IPv6 prefix.
 269         :param ipv4_src: IPv4 source address
 270         :type ipv6_pfx: str
 271         :type ipv4_src: str
 272         :returns: IPv6 address, combination of IPv6 prefix and IPv4 address.
 273         :rtype: str
 274         """
 275         ipv6_net = ipaddress.ip_network(unicode(ipv6_pfx))
 276         ipv4_host = ipaddress.ip_address(unicode(ipv4_src))
 277
 278         address = ipv6_net.network_address._ip
 279         address |= ipv4_host._ip
 280
 281         return str(ipaddress.ip_address(address))