test/vpp_interface.py

   1 from abc import abstractmethod, ABCMeta
   2 import socket
   3 from logging import info, error
   4 from scapy.layers.l2 import Ether, ARP
   5
   6 from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6ND_NA, ICMPv6NDOptSrcLLAddr, ICMPv6NDOptDstLLAddr
   7
   8
   9 class VppInterface(object):
  10     """
  11     Generic VPP interface
  12     """
  13     __metaclass__ = ABCMeta
  14
  15     @property
  16     def sw_if_index(self):
  17         """Interface index assigned by VPP"""
  18         return self._sw_if_index
  19
  20     @property
  21     def remote_mac(self):
  22         """MAC-address of the remote interface "connected" to this interface"""
  23         return self._remote_mac
  24
  25     @property
  26     def local_mac(self):
  27         """MAC-address of the VPP interface"""
  28         return self._local_mac
  29
  30     @property
  31     def local_ip4(self):
  32         """Local IPv4 address on VPP interface (string)"""
  33         return self._local_ip4
  34
  35     @property
  36     def local_ip4n(self):
  37         """Local IPv4 address - raw, suitable as API parameter"""
  38         return self._local_ip4n
  39
  40     @property
  41     def remote_ip4(self):
  42         """IPv4 address of remote peer "connected" to this interface"""
  43         return self._remote_ip4
  44
  45     @property
  46     def remote_ip4n(self):
  47         """IPv4 address of remote peer - raw, suitable as API parameter"""
  48         return self._remote_ip4n
  49
  50     @property
  51     def local_ip6(self):
  52         """Local IPv6 address on VPP interface (string)"""
  53         return self._local_ip6
  54
  55     @property
  56     def local_ip6n(self):
  57         """Local IPv6 address - raw, suitable as API parameter"""
  58         return self._local_ip6n
  59
  60     @property
  61     def remote_ip6(self):
  62         """IPv6 address of remote peer "connected" to this interface"""
  63         return self._remote_ip6
  64
  65     @property
  66     def remote_ip6n(self):
  67         """IPv6 address of remote peer - raw, suitable as API parameter"""
  68         return self._remote_ip6n
  69
  70     @property
  71     def name(self):
  72         """Name of the interface"""
  73         return self._name
  74
  75     @property
  76     def dump(self):
  77         """Raw result of sw_interface_dump for this interface"""
  78         return self._dump
  79
  80     @property
  81     def test(self):
  82         """Test case creating this interface"""
  83         return self._test
  84
  85     def post_init_setup(self):
  86         """Additional setup run after creating an interface object"""
  87         self._remote_mac = "02:00:00:00:ff:%02x" % self.sw_if_index
  88
  89         self._local_ip4 = "172.16.%u.1" % self.sw_if_index
  90         self._local_ip4n = socket.inet_pton(socket.AF_INET, self.local_ip4)
  91         self._remote_ip4 = "172.16.%u.2" % self.sw_if_index
  92         self._remote_ip4n = socket.inet_pton(socket.AF_INET, self.remote_ip4)
  93
  94         self._local_ip6 = "fd01:%u::1" % self.sw_if_index
  95         self._local_ip6n = socket.inet_pton(socket.AF_INET6, self.local_ip6)
  96         self._remote_ip6 = "fd01:%u::2" % self.sw_if_index
  97         self._remote_ip6n = socket.inet_pton(socket.AF_INET6, self.remote_ip6)
  98
  99         r = self.test.vapi.sw_interface_dump()
 100         for intf in r:
 101             if intf.sw_if_index == self.sw_if_index:
 102                 self._name = intf.interface_name.split(b'\0', 1)[0]
 103                 self._local_mac = ':'.join(intf.l2_address.encode('hex')[i:i + 2]
 104                                            for i in range(0, 12, 2))
 105                 self._dump = intf
 106                 break
 107         else:
 108             raise Exception(
 109                 "Could not find interface with sw_if_index %d "
 110                 "in interface dump %s" %
 111                 (self.sw_if_index, repr(r)))
 112
 113     @abstractmethod
 114     def __init__(self, test, index):
 115         self._test = test
 116         self.post_init_setup()
 117         info("New %s, MAC=%s, remote_ip4=%s, local_ip4=%s" %
 118              (self.__name__, self.remote_mac, self.remote_ip4, self.local_ip4))
 119
 120     def config_ip4(self):
 121         """Configure IPv4 address on the VPP interface"""
 122         addr = self.local_ip4n
 123         addr_len = 24
 124         self.test.vapi.sw_interface_add_del_address(
 125             self.sw_if_index, addr, addr_len)
 126
 127     def config_ip6(self):
 128         """Configure IPv6 address on the VPP interface"""
 129         addr = self._local_ip6n
 130         addr_len = 64
 131         self.test.vapi.sw_interface_add_del_address(
 132             self.sw_if_index, addr, addr_len, is_ipv6=1)
 133
 134     def set_table_ip4(self, table_id):
 135         """Set the interface in a IPv4 Table.
 136         Must be called before configuring IP4 addresses"""
 137         self.test.vapi.sw_interface_set_table(
 138             self.sw_if_index, 0, table_id)
 139
 140     def set_table_ip6(self, table_id):
 141         """Set the interface in a IPv6 Table.
 142         Must be called before configuring IP6 addresses"""
 143         self.test.vapi.sw_interface_set_table(
 144             self.sw_if_index, 1, table_id)
 145
 146     def disable_ipv6_ra(self):
 147         """Configure IPv6 RA suppress on the VPP interface"""
 148         self.test.vapi.sw_interface_ra_suppress(self.sw_if_index)
 149
 150     def create_arp_req(self):
 151         """Create ARP request applicable for this interface"""
 152         return (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.remote_mac) /
 153                 ARP(op=ARP.who_has, pdst=self.local_ip4,
 154                     psrc=self.remote_ip4, hwsrc=self.remote_mac))
 155
 156     def create_ndp_req(self):
 157         return (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.remote_mac) /
 158               IPv6(src=self.remote_ip6, dst=self.local_ip6) /
 159               ICMPv6ND_NS(tgt=self.local_ip6) /
 160               ICMPv6NDOptSrcLLAddr(lladdr=self.remote_mac))
 161
 162     def resolve_arp(self, pg_interface=None):
 163         """Resolve ARP using provided packet-generator interface
 164
 165         :param pg_interface: interface used to resolve, if None then this
 166             interface is used
 167
 168         """
 169         if pg_interface is None:
 170             pg_interface = self
 171         info("Sending ARP request for %s on port %s" %
 172              (self.local_ip4, pg_interface.name))
 173         arp_req = self.create_arp_req()
 174         pg_interface.add_stream(arp_req)
 175         pg_interface.enable_capture()
 176         self.test.pg_start()
 177         info(self.test.vapi.cli("show trace"))
 178         arp_reply = pg_interface.get_capture()
 179         if arp_reply is None or len(arp_reply) == 0:
 180             info("No ARP received on port %s" % pg_interface.name)
 181             return
 182         arp_reply = arp_reply[0]
 183         # Make Dot1AD packet content recognizable to scapy
 184         if arp_reply.type == 0x88a8:
 185             arp_reply.type = 0x8100
 186             arp_reply = Ether(str(arp_reply))
 187         try:
 188             if arp_reply[ARP].op == ARP.is_at:
 189                 info("VPP %s MAC address is %s " %
 190                      (self.name, arp_reply[ARP].hwsrc))
 191                 self._local_mac = arp_reply[ARP].hwsrc
 192             else:
 193                 info("No ARP received on port %s" % pg_interface.name)
 194         except:
 195             error("Unexpected response to ARP request:")
 196             error(arp_reply.show())
 197             raise
 198
 199     def resolve_ndp(self, pg_interface=None):
 200         """Resolve NDP using provided packet-generator interface
 201
 202         :param pg_interface: interface used to resolve, if None then this
 203             interface is used
 204
 205         """
 206         if pg_interface is None:
 207             pg_interface = self
 208         info("Sending NDP request for %s on port %s" %
 209              (self.local_ip6, pg_interface.name))
 210         ndp_req = self.create_ndp_req()
 211         pg_interface.add_stream(ndp_req)
 212         pg_interface.enable_capture()
 213         self.test.pg_start()
 214         info(self.test.vapi.cli("show trace"))
 215         ndp_reply = pg_interface.get_capture()
 216         if ndp_reply is None or len(ndp_reply) == 0:
 217             info("No NDP received on port %s" % pg_interface.name)
 218             return
 219         ndp_reply = ndp_reply[0]
 220         # Make Dot1AD packet content recognizable to scapy
 221         if ndp_reply.type == 0x88a8:
 222             ndp_reply.type = 0x8100
 223             ndp_reply = Ether(str(ndp_reply))
 224         try:
 225             ndp_na = ndp_reply[ICMPv6ND_NA]
 226             opt = ndp_na[ICMPv6NDOptDstLLAddr]
 227             info("VPP %s MAC address is %s " %
 228                  (self.name, opt.lladdr))
 229             self._local_mac = opt.lladdr
 230         except:
 231             error("Unexpected response to NDP request:")
 232             error(ndp_reply.show())
 233             raise
 234
 235     def admin_up(self):
 236         """ Put interface ADMIN-UP """
 237         self.test.vapi.sw_interface_set_flags(self.sw_if_index, admin_up_down=1)
 238
 239     def add_sub_if(self, sub_if):
 240         """
 241         Register a sub-interface with this interface
 242
 243         :param sub_if: sub-interface
 244
 245         """
 246         if not hasattr(self, 'sub_if'):
 247             self.sub_if = sub_if
 248         else:
 249             if isinstance(self.sub_if, list):
 250                 self.sub_if.append(sub_if)
 251             else:
 252                 self.sub_if = sub_if
 253
 254     def enable_mpls(self):
 255         """Enable MPLS on the VPP interface"""
 256         self.test.vapi.sw_interface_enable_disable_mpls(
 257             self.sw_if_index)