#!/usr/bin/env python3
#
#   Copyright 2016 - Google, Inc.
#
#   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.

import collections
import ipaddress
import os
import time
from typing import FrozenSet, Set

from acts import logger
from acts import utils

from acts.controllers import pdu
from acts.controllers.ap_lib import ap_get_interface
from acts.controllers.ap_lib import ap_iwconfig
from acts.controllers.ap_lib import bridge_interface
from acts.controllers.ap_lib import dhcp_config
from acts.controllers.ap_lib import dhcp_server
from acts.controllers.ap_lib import hostapd
from acts.controllers.ap_lib import hostapd_ap_preset
from acts.controllers.ap_lib import hostapd_constants
from acts.controllers.ap_lib import hostapd_config
from acts.controllers.ap_lib import radvd
from acts.controllers.ap_lib import radvd_config
from acts.controllers.ap_lib.extended_capabilities import ExtendedCapabilities
from acts.controllers.ap_lib.wireless_network_management import BssTransitionManagementRequest
from acts.controllers.utils_lib.commands import ip
from acts.controllers.utils_lib.commands import route
from acts.controllers.utils_lib.commands import shell
from acts.controllers.utils_lib.ssh import connection
from acts.controllers.utils_lib.ssh import settings
from acts.libs.proc import job

MOBLY_CONTROLLER_CONFIG_NAME = 'AccessPoint'
ACTS_CONTROLLER_REFERENCE_NAME = 'access_points'
_BRCTL = 'brctl'

LIFETIME = 180
PROC_NET_SNMP6 = '/proc/net/snmp6'
SCAPY_INSTALL_COMMAND = 'sudo python setup.py install'
RA_MULTICAST_ADDR = '33:33:00:00:00:01'
RA_SCRIPT = 'sendra.py'


def create(configs):
    """Creates ap controllers from a json config.

    Creates an ap controller from either a list, or a single
    element. The element can either be just the hostname or a dictionary
    containing the hostname and username of the ap to connect to over ssh.

    Args:
        The json configs that represent this controller.

    Returns:
        A new AccessPoint.
    """
    return [AccessPoint(c) for c in configs]


def destroy(aps):
    """Destroys a list of access points.

    Args:
        aps: The list of access points to destroy.
    """
    for ap in aps:
        ap.close()


def get_info(aps):
    """Get information on a list of access points.

    Args:
        aps: A list of AccessPoints.

    Returns:
        A list of all aps hostname.
    """
    return [ap.ssh_settings.hostname for ap in aps]


def setup_ap(
        access_point,
        profile_name,
        channel,
        ssid,
        mode=None,
        preamble=None,
        beacon_interval=None,
        dtim_period=None,
        frag_threshold=None,
        rts_threshold=None,
        force_wmm=None,
        hidden=False,
        security=None,
        pmf_support=None,
        additional_ap_parameters=None,
        password=None,
        n_capabilities=None,
        ac_capabilities=None,
        vht_bandwidth=None,
        wnm_features: FrozenSet[hostapd_constants.WnmFeature] = frozenset(),
        setup_bridge=False,
        is_ipv6_enabled=False,
        is_nat_enabled=True):
    """Creates a hostapd profile and runs it on an ap. This is a convenience
    function that allows us to start an ap with a single function, without first
    creating a hostapd config.

    Args:
        access_point: An ACTS access_point controller
        profile_name: The profile name of one of the hostapd ap presets.
        channel: What channel to set the AP to.
        preamble: Whether to set short or long preamble (True or False)
        beacon_interval: The beacon interval (int)
        dtim_period: Length of dtim period (int)
        frag_threshold: Fragmentation threshold (int)
        rts_threshold: RTS threshold (int)
        force_wmm: Enable WMM or not (True or False)
        hidden: Advertise the SSID or not (True or False)
        security: What security to enable.
        pmf_support: int, whether pmf is not disabled, enabled, or required
        additional_ap_parameters: Additional parameters to send the AP.
        password: Password to connect to WLAN if necessary.
        check_connectivity: Whether to check for internet connectivity.
        wnm_features: WNM features to enable on the AP.
        setup_bridge: Whether to bridge the LAN interface WLAN interface.
            Only one WLAN interface can be bridged with the LAN interface
            and none of the guest networks can be bridged.
        is_ipv6_enabled: If True, start a IPv6 router advertisement daemon
        is_nat_enabled: If True, start NAT on the AP to allow the DUT to be able
            to access the internet if the WAN port is connected to the internet.

    Returns:
        An identifier for each ssid being started. These identifiers can be
        used later by this controller to control the ap.

    Raises:
        Error: When the ap can't be brought up.
    """
    ap = hostapd_ap_preset.create_ap_preset(profile_name=profile_name,
                                            iface_wlan_2g=access_point.wlan_2g,
                                            iface_wlan_5g=access_point.wlan_5g,
                                            channel=channel,
                                            ssid=ssid,
                                            mode=mode,
                                            short_preamble=preamble,
                                            beacon_interval=beacon_interval,
                                            dtim_period=dtim_period,
                                            frag_threshold=frag_threshold,
                                            rts_threshold=rts_threshold,
                                            force_wmm=force_wmm,
                                            hidden=hidden,
                                            bss_settings=[],
                                            security=security,
                                            pmf_support=pmf_support,
                                            n_capabilities=n_capabilities,
                                            ac_capabilities=ac_capabilities,
                                            vht_bandwidth=vht_bandwidth,
                                            wnm_features=wnm_features)
    return access_point.start_ap(
        hostapd_config=ap,
        radvd_config=radvd_config.RadvdConfig() if is_ipv6_enabled else None,
        setup_bridge=setup_bridge,
        is_nat_enabled=is_nat_enabled,
        additional_parameters=additional_ap_parameters)


class Error(Exception):
    """Error raised when there is a problem with the access point."""


_ApInstance = collections.namedtuple('_ApInstance', ['hostapd', 'subnet'])

# These ranges were split this way since each physical radio can have up
# to 8 SSIDs so for the 2GHz radio the DHCP range will be
# 192.168.1 - 8 and the 5Ghz radio will be 192.168.9 - 16
_AP_2GHZ_SUBNET_STR_DEFAULT = '192.168.1.0/24'
_AP_5GHZ_SUBNET_STR_DEFAULT = '192.168.9.0/24'

# The last digit of the ip for the bridge interface
BRIDGE_IP_LAST = '100'


class AccessPoint(object):
    """An access point controller.

    Attributes:
        ssh: The ssh connection to this ap.
        ssh_settings: The ssh settings being used by the ssh connection.
        dhcp_settings: The dhcp server settings being used.
    """

    def __init__(self, configs):
        """
        Args:
            configs: configs for the access point from config file.
        """
        self.ssh_settings = settings.from_config(configs['ssh_config'])
        self.log = logger.create_logger(
            lambda msg: f'[Access Point|{self.ssh_settings.hostname}] {msg}')
        self.device_pdu_config = configs.get('PduDevice', None)
        self.identifier = self.ssh_settings.hostname

        if 'ap_subnet' in configs:
            self._AP_2G_SUBNET_STR = configs['ap_subnet']['2g']
            self._AP_5G_SUBNET_STR = configs['ap_subnet']['5g']
        else:
            self._AP_2G_SUBNET_STR = _AP_2GHZ_SUBNET_STR_DEFAULT
            self._AP_5G_SUBNET_STR = _AP_5GHZ_SUBNET_STR_DEFAULT

        self._AP_2G_SUBNET = dhcp_config.Subnet(
            ipaddress.ip_network(self._AP_2G_SUBNET_STR))
        self._AP_5G_SUBNET = dhcp_config.Subnet(
            ipaddress.ip_network(self._AP_5G_SUBNET_STR))

        self.ssh = connection.SshConnection(self.ssh_settings)

        # Singleton utilities for running various commands.
        self._ip_cmd = ip.LinuxIpCommand(self.ssh)
        self._route_cmd = route.LinuxRouteCommand(self.ssh)

        # A map from network interface name to _ApInstance objects representing
        # the hostapd instance running against the interface.
        self._aps = dict()
        self._dhcp = None
        self._dhcp_bss = dict()
        self._radvd = None
        self.bridge = bridge_interface.BridgeInterface(self)
        self.iwconfig = ap_iwconfig.ApIwconfig(self)

        # Check to see if wan_interface is specified in acts_config for tests
        # isolated from the internet and set this override.
        self.interfaces = ap_get_interface.ApInterfaces(
            self, configs.get('wan_interface'))

        # Get needed interface names and initialize the unnecessary ones.
        self.wan = self.interfaces.get_wan_interface()
        self.wlan = self.interfaces.get_wlan_interface()
        self.wlan_2g = self.wlan[0]
        self.wlan_5g = self.wlan[1]
        self.lan = self.interfaces.get_lan_interface()
        self._initial_ap()
        self.scapy_install_path = None
        self.setup_bridge = False

    def _initial_ap(self):
        """Initial AP interfaces.

        Bring down hostapd if instance is running, bring down all bridge
        interfaces.
        """
        # This is necessary for Gale/Whirlwind flashed with dev channel image
        # Unused interfaces such as existing hostapd daemon, guest, mesh
        # interfaces need to be brought down as part of the AP initialization
        # process, otherwise test would fail.
        try:
            self.ssh.run('stop wpasupplicant')
        except job.Error:
            self.log.info('No wpasupplicant running')
        try:
            self.ssh.run('stop hostapd')
        except job.Error:
            self.log.info('No hostapd running')
        # Bring down all wireless interfaces
        for iface in self.wlan:
            WLAN_DOWN = f'ip link set {iface} down'
            self.ssh.run(WLAN_DOWN)
        # Bring down all bridge interfaces
        bridge_interfaces = self.interfaces.get_bridge_interface()
        if bridge_interfaces:
            for iface in bridge_interfaces:
                BRIDGE_DOWN = f'ip link set {iface} down'
                BRIDGE_DEL = f'brctl delbr {iface}'
                self.ssh.run(BRIDGE_DOWN)
                self.ssh.run(BRIDGE_DEL)

    def start_ap(self,
                 hostapd_config,
                 radvd_config=None,
                 setup_bridge=False,
                 is_nat_enabled=True,
                 additional_parameters=None):
        """Starts as an ap using a set of configurations.

        This will start an ap on this host. To start an ap the controller
        selects a network interface to use based on the configs given. It then
        will start up hostapd on that interface. Next a subnet is created for
        the network interface and dhcp server is refreshed to give out ips
        for that subnet for any device that connects through that interface.

        Args:
            hostapd_config: hostapd_config.HostapdConfig, The configurations
                to use when starting up the ap.
            radvd_config: radvd_config.RadvdConfig, The IPv6 configuration
                to use when starting up the ap.
            setup_bridge: Whether to bridge the LAN interface WLAN interface.
                Only one WLAN interface can be bridged with the LAN interface
                and none of the guest networks can be bridged.
            is_nat_enabled: If True, start NAT on the AP to allow the DUT to be
                able to access the internet if the WAN port is connected to the
                internet.
            additional_parameters: A dictionary of parameters that can sent
                directly into the hostapd config file.  This can be used for
                debugging and or adding one off parameters into the config.

        Returns:
            An identifier for each ssid being started. These identifiers can be
            used later by this controller to control the ap.

        Raises:
            Error: When the ap can't be brought up.
        """
        if hostapd_config.frequency < 5000:
            interface = self.wlan_2g
            subnet = self._AP_2G_SUBNET
        else:
            interface = self.wlan_5g
            subnet = self._AP_5G_SUBNET

        # In order to handle dhcp servers on any interface, the initiation of
        # the dhcp server must be done after the wlan interfaces are figured
        # out as opposed to being in __init__
        self._dhcp = dhcp_server.DhcpServer(self.ssh, interface=interface)

        # For multi bssid configurations the mac address
        # of the wireless interface needs to have enough space to mask out
        # up to 8 different mac addresses. So in for one interface the range is
        # hex 0-7 and for the other the range is hex 8-f.
        interface_mac_orig = None
        cmd = f"ip link show {interface}|grep ether|awk -F' ' '{{print $2}}'"
        interface_mac_orig = self.ssh.run(cmd)
        if interface == self.wlan_5g:
            hostapd_config.bssid = interface_mac_orig.stdout[:-1] + '0'
            last_octet = 1
        if interface == self.wlan_2g:
            hostapd_config.bssid = interface_mac_orig.stdout[:-1] + '8'
            last_octet = 9
        if interface in self._aps:
            raise ValueError('No WiFi interface available for AP on '
                             f'channel {hostapd_config.channel}')

        apd = hostapd.Hostapd(self.ssh, interface)
        new_instance = _ApInstance(hostapd=apd, subnet=subnet)
        self._aps[interface] = new_instance

        # Turn off the DHCP server, we're going to change its settings.
        self.stop_dhcp()
        # Clear all routes to prevent old routes from interfering.
        self._route_cmd.clear_routes(net_interface=interface)

        self._dhcp_bss = dict()
        if hostapd_config.bss_lookup:
            # The self._dhcp_bss dictionary is created to hold the key/value
            # pair of the interface name and the ip scope that will be
            # used for the particular interface.  The a, b, c, d
            # variables below are the octets for the ip address.  The
            # third octet is then incremented for each interface that
            # is requested.  This part is designed to bring up the
            # hostapd interfaces and not the DHCP servers for each
            # interface.
            counter = 1
            for bss in hostapd_config.bss_lookup:
                if interface_mac_orig:
                    hostapd_config.bss_lookup[bss].bssid = (
                        interface_mac_orig.stdout[:-1] + hex(last_octet)[-1:])
                self._route_cmd.clear_routes(net_interface=str(bss))
                if interface is self.wlan_2g:
                    starting_ip_range = self._AP_2G_SUBNET_STR
                else:
                    starting_ip_range = self._AP_5G_SUBNET_STR
                a, b, c, d = starting_ip_range.split('.')
                self._dhcp_bss[bss] = dhcp_config.Subnet(
                    ipaddress.ip_network(f'{a}.{b}.{int(c) + counter}.{d}'))
                counter = counter + 1
                last_octet = last_octet + 1

        apd.start(hostapd_config, additional_parameters=additional_parameters)

        # The DHCP serer requires interfaces to have ips and routes before
        # the server will come up.
        interface_ip = ipaddress.ip_interface(
            f'{subnet.router}/{subnet.network.netmask}')
        if setup_bridge is True:
            bridge_interface_name = 'eth_test'
            self.create_bridge(bridge_interface_name, [interface, self.lan])
            self._ip_cmd.set_ipv4_address(bridge_interface_name, interface_ip)
        else:
            self._ip_cmd.set_ipv4_address(interface, interface_ip)
        if hostapd_config.bss_lookup:
            # This loop goes through each interface that was setup for
            # hostapd and assigns the DHCP scopes that were defined but
            # not used during the hostapd loop above.  The k and v
            # variables represent the interface name, k, and dhcp info, v.
            for k, v in self._dhcp_bss.items():
                bss_interface_ip = ipaddress.ip_interface(
                    f'{self._dhcp_bss[k].router}/{self._dhcp_bss[k].network.netmask}'
                )
                self._ip_cmd.set_ipv4_address(str(k), bss_interface_ip)

        # Restart the DHCP server with our updated list of subnets.
        configured_subnets = self.get_configured_subnets()
        dhcp_conf = dhcp_config.DhcpConfig(subnets=configured_subnets)
        self.start_dhcp(dhcp_conf=dhcp_conf)
        if is_nat_enabled:
            self.start_nat()
            self.enable_forwarding()
        else:
            self.stop_nat()
            self.enable_forwarding()
        if radvd_config:
            radvd_interface = bridge_interface_name if setup_bridge else interface
            self._radvd = radvd.Radvd(self.ssh, radvd_interface)
            self._radvd.start(radvd_config)

        bss_interfaces = [bss for bss in hostapd_config.bss_lookup]
        bss_interfaces.append(interface)

        return bss_interfaces

    def get_configured_subnets(self):
        """Get the list of configured subnets on the access point.

        This allows consumers of the access point objects create custom DHCP
        configs with the correct subnets.

        Returns: a list of dhcp_config.Subnet objects
        """
        configured_subnets = [x.subnet for x in self._aps.values()]
        for k, v in self._dhcp_bss.items():
            configured_subnets.append(v)
        return configured_subnets

    def start_dhcp(self, dhcp_conf):
        """Start a DHCP server for the specified subnets.

        This allows consumers of the access point objects to control DHCP.

        Args:
            dhcp_conf: A dhcp_config.DhcpConfig object.

        Raises:
            Error: Raised when a dhcp server error is found.
        """
        self._dhcp.start(config=dhcp_conf)

    def stop_dhcp(self):
        """Stop DHCP for this AP object.

        This allows consumers of the access point objects to control DHCP.
        """
        self._dhcp.stop()

    def get_dhcp_logs(self):
        """Get DHCP logs for this AP object.

        This allows consumers of the access point objects to validate DHCP
        behavior.

        Returns:
            A string of the dhcp server logs, or None is a DHCP server has not
            been started.
        """
        if self._dhcp:
            return self._dhcp.get_logs()
        return None

    def get_hostapd_logs(self):
        """Get hostapd logs for all interfaces on AP object.

        This allows consumers of the access point objects to validate hostapd
        behavior.

        Returns: A dict with {interface: log} from hostapd instances.
        """
        hostapd_logs = dict()
        for identifier in self._aps:
            hostapd_logs[identifier] = self._aps.get(
                identifier).hostapd.pull_logs()
        return hostapd_logs

    def enable_forwarding(self):
        """Enable IPv4 and IPv6 forwarding on the AP.

        When forwarding is enabled, the access point is able to route IP packets
        between devices in the same subnet.
        """
        self.ssh.run('echo 1 > /proc/sys/net/ipv4/ip_forward')
        self.ssh.run('echo 1 > /proc/sys/net/ipv6/conf/all/forwarding')

    def start_nat(self):
        """Start NAT on the AP.

        This allows consumers of the access point objects to enable NAT
        on the AP.

        Note that this is currently a global setting, since we don't
        have per-interface masquerade rules.
        """
        # The following three commands are needed to enable NAT between
        # the WAN and LAN/WLAN ports.  This means anyone connecting to the
        # WLAN/LAN ports will be able to access the internet if the WAN port
        # is connected to the internet.
        self.ssh.run('iptables -t nat -F')
        self.ssh.run(
            f'iptables -t nat -A POSTROUTING -o {self.wan} -j MASQUERADE')

    def stop_nat(self):
        """Stop NAT on the AP.

        This allows consumers of the access point objects to disable NAT on the
        AP.

        Note that this is currently a global setting, since we don't have
        per-interface masquerade rules.
        """
        self.ssh.run('iptables -t nat -F')

    def create_bridge(self, bridge_name, interfaces):
        """Create the specified bridge and bridge the specified interfaces.

        Args:
            bridge_name: The name of the bridge to create.
            interfaces: A list of interfaces to add to the bridge.
        """

        # Create the bridge interface
        self.ssh.run(f'brctl addbr {bridge_name}')

        for interface in interfaces:
            self.ssh.run(f'brctl addif {bridge_name} {interface}')

        self.ssh.run(f'ip link set {bridge_name} up')

    def remove_bridge(self, bridge_name):
        """Removes the specified bridge

        Args:
            bridge_name: The name of the bridge to remove.
        """
        # Check if the bridge exists.
        #
        # Cases where it may not are if we failed to initialize properly
        #
        # Or if we're doing 2.4Ghz and 5Ghz SSIDs and we've already torn
        # down the bridge once, but we got called for each band.
        result = self.ssh.run(f'brctl show {bridge_name}', ignore_status=True)

        # If the bridge exists, we'll get an exit_status of 0, indicating
        # success, so we can continue and remove the bridge.
        if result.exit_status == 0:
            self.ssh.run(f'ip link set {bridge_name} down')
            self.ssh.run(f'brctl delbr {bridge_name}')

    def get_bssid_from_ssid(self, ssid, band):
        """Gets the BSSID from a provided SSID

        Args:
            ssid: An SSID string.
            band: 2G or 5G Wifi band.
        Returns: The BSSID if on the AP or None if SSID could not be found.
        """
        if band == hostapd_constants.BAND_2G:
            interfaces = [self.wlan_2g, ssid]
        else:
            interfaces = [self.wlan_5g, ssid]

        # Get the interface name associated with the given ssid.
        for interface in interfaces:
            iw_output = self.ssh.run(
                f"iw dev {interface} info|grep ssid|awk -F' ' '{{print $2}}'")
            if 'command failed: No such device' in iw_output.stderr:
                continue
            else:
                # If the configured ssid is equal to the given ssid, we found
                # the right interface.
                if iw_output.stdout == ssid:
                    iw_output = self.ssh.run(
                        f"iw dev {interface} info|grep addr|awk -F' ' '{{print $2}}'"
                    )
                    return iw_output.stdout
        return None

    def stop_ap(self, identifier):
        """Stops a running ap on this controller.

        Args:
            identifier: The identify of the ap that should be taken down.
        """

        if identifier not in list(self._aps.keys()):
            raise ValueError(f'Invalid identifier {identifier} given')

        instance = self._aps.get(identifier)

        if self._radvd:
            self._radvd.stop()
        try:
            self.stop_dhcp()
        except dhcp_server.NoInterfaceError:
            pass
        self.stop_nat()
        instance.hostapd.stop()
        self._ip_cmd.clear_ipv4_addresses(identifier)

        del self._aps[identifier]
        bridge_interfaces = self.interfaces.get_bridge_interface()
        if bridge_interfaces:
            for iface in bridge_interfaces:
                BRIDGE_DOWN = f'ip link set {iface} down'
                BRIDGE_DEL = f'brctl delbr {iface}'
                self.ssh.run(BRIDGE_DOWN)
                self.ssh.run(BRIDGE_DEL)

    def stop_all_aps(self):
        """Stops all running aps on this device."""

        for ap in list(self._aps.keys()):
            self.stop_ap(ap)

    def close(self):
        """Called to take down the entire access point.

        When called will stop all aps running on this host, shutdown the dhcp
        server, and stop the ssh connection.
        """

        if self._aps:
            self.stop_all_aps()
        self.ssh.close()

    def generate_bridge_configs(self, channel):
        """Generate a list of configs for a bridge between LAN and WLAN.

        Args:
            channel: the channel WLAN interface is brought up on
            iface_lan: the LAN interface to bridge
        Returns:
            configs: tuple containing iface_wlan, iface_lan and bridge_ip
        """

        if channel < 15:
            iface_wlan = self.wlan_2g
            subnet_str = self._AP_2G_SUBNET_STR
        else:
            iface_wlan = self.wlan_5g
            subnet_str = self._AP_5G_SUBNET_STR

        iface_lan = self.lan

        a, b, c, _ = subnet_str.strip('/24').split('.')
        bridge_ip = f'{a}.{b}.{c}.{BRIDGE_IP_LAST}'

        configs = (iface_wlan, iface_lan, bridge_ip)

        return configs

    def install_scapy(self, scapy_path, send_ra_path):
        """Install scapy

        Args:
            scapy_path: path where scapy tar file is located on server
            send_ra_path: path where sendra path is located on server
        """
        self.scapy_install_path = self.ssh.run('mktemp -d').stdout.rstrip()
        self.log.info(f'Scapy install path: {self.scapy_install_path}')
        self.ssh.send_file(scapy_path, self.scapy_install_path)
        self.ssh.send_file(send_ra_path, self.scapy_install_path)

        scapy = os.path.join(self.scapy_install_path,
                             scapy_path.split('/')[-1])

        self.ssh.run(f'tar -xvf {scapy} -C {self.scapy_install_path}')
        self.ssh.run(f'cd {self.scapy_install_path}; {SCAPY_INSTALL_COMMAND}')

    def cleanup_scapy(self):
        """ Cleanup scapy """
        if self.scapy_install_path:
            cmd = f'rm -rf {self.scapy_install_path}'
            self.log.info(f'Cleaning up scapy {cmd}')
            output = self.ssh.run(cmd)
            self.scapy_install_path = None

    def send_ra(self,
                iface,
                mac=RA_MULTICAST_ADDR,
                interval=1,
                count=None,
                lifetime=LIFETIME,
                rtt=0):
        """Invoke scapy and send RA to the device.

        Args:
          iface: string of the WiFi interface to use for sending packets.
          mac: string HWAddr/MAC address to send the packets to.
          interval: int Time to sleep between consecutive packets.
          count: int Number of packets to be sent.
          lifetime: int original RA's router lifetime in seconds.
          rtt: retrans timer of the RA packet
        """
        scapy_command = os.path.join(self.scapy_install_path, RA_SCRIPT)
        options = f' -m {mac} -i {interval} -c {count} -l {lifetime} -in {iface} -rtt {rtt}'
        cmd = scapy_command + options
        self.log.info(f'Scapy cmd: {cmd}')
        self.ssh.run(cmd)

    def get_icmp6intype134(self):
        """Read the value of Icmp6InType134 and return integer.

        Returns:
            Integer value >0 if grep is successful; 0 otherwise.
        """
        ra_count_str = self.ssh.run(
            f'grep Icmp6InType134 {PROC_NET_SNMP6} || true').stdout
        if ra_count_str:
            return int(ra_count_str.split()[1])

    def ping(self,
             dest_ip,
             count=3,
             interval=1000,
             timeout=1000,
             size=56,
             additional_ping_params=None):
        """Pings from AP to dest_ip, returns dict of ping stats (see utils.ping)
        """
        return utils.ping(self.ssh,
                          dest_ip,
                          count=count,
                          interval=interval,
                          timeout=timeout,
                          size=size,
                          additional_ping_params=additional_ping_params)

    def can_ping(self,
                 dest_ip,
                 count=1,
                 interval=1000,
                 timeout=1000,
                 size=56,
                 additional_ping_params=None):
        """Returns whether ap can ping dest_ip (see utils.can_ping)"""
        return utils.can_ping(self.ssh,
                              dest_ip,
                              count=count,
                              interval=interval,
                              timeout=timeout,
                              size=size,
                              additional_ping_params=additional_ping_params)

    def hard_power_cycle(self,
                         pdus,
                         unreachable_timeout=30,
                         ping_timeout=60,
                         ssh_timeout=30,
                         hostapd_configs=None):
        """Kills, then restores power to AccessPoint, verifying it goes down and
        comes back online cleanly.

        Args:
            pdus: list, PduDevices in the testbed
            unreachable_timeout: int, time to wait for AccessPoint to become
                unreachable
            ping_timeout: int, time to wait for AccessPoint to responsd to pings
            ssh_timeout: int, time to wait for AccessPoint to allow SSH
            hostapd_configs (optional): list, containing hostapd settings. If
                present, these networks will be spun up after the AP has
                rebooted. This list can either contain HostapdConfig objects, or
                    dictionaries with the start_ap params
                    (i.e  { 'hostapd_config': <HostapdConfig>,
                            'setup_bridge': <bool>,
                            'additional_parameters': <dict> } ).
        Raise:
            Error, if no PduDevice is provided in AccessPoint config.
            ConnectionError, if AccessPoint fails to go offline or come back.
        """
        if not self.device_pdu_config:
            raise Error('No PduDevice provided in AccessPoint config.')

        if hostapd_configs is None:
            hostapd_configs = []

        self.log.info(f'Power cycling')
        ap_pdu, ap_pdu_port = pdu.get_pdu_port_for_device(
            self.device_pdu_config, pdus)

        self.log.info(f'Killing power')
        ap_pdu.off(str(ap_pdu_port))

        self.log.info('Verifying AccessPoint is unreachable.')
        timeout = time.time() + unreachable_timeout
        while time.time() < timeout:
            if not utils.can_ping(job, self.ssh_settings.hostname):
                self.log.info('AccessPoint is unreachable as expected.')
                break
            else:
                self.log.debug(
                    'AccessPoint is still responding to pings. Retrying in 1 '
                    'second.')
                time.sleep(1)
        else:
            raise ConnectionError(
                f'Failed to bring down AccessPoint ({self.ssh_settings.hostname})'
            )
        self._aps.clear()

        self.log.info(f'Restoring power')
        ap_pdu.on(str(ap_pdu_port))

        self.log.info('Waiting for AccessPoint to respond to pings.')
        timeout = time.time() + ping_timeout
        while time.time() < timeout:
            if utils.can_ping(job, self.ssh_settings.hostname):
                self.log.info('AccessPoint responded to pings.')
                break
            else:
                self.log.debug('AccessPoint is not responding to pings. '
                               'Retrying in 1 second.')
                time.sleep(1)
        else:
            raise ConnectionError(
                f'Timed out waiting for AccessPoint ({self.ssh_settings.hostname}) '
                'to respond to pings.')

        self.log.info('Waiting for AccessPoint to allow ssh connection.')
        timeout = time.time() + ssh_timeout
        while time.time() < timeout:
            try:
                self.ssh.run('echo')
            except connection.Error:
                self.log.debug('AccessPoint is not allowing ssh connection. '
                               'Retrying in 1 second.')
                time.sleep(1)
            else:
                self.log.info('AccessPoint available via ssh.')
                break
        else:
            raise ConnectionError(
                f'Timed out waiting for AccessPoint ({self.ssh_settings.hostname}) '
                'to allow ssh connection.')

        # Allow 5 seconds for OS to finish getting set up
        time.sleep(5)
        self._initial_ap()
        self.log.info('Power cycled successfully')

        for settings in hostapd_configs:
            if type(settings) == hostapd_config.HostapdConfig:
                config = settings
                setup_bridge = False
                additional_parameters = None

            elif type(settings) == dict:
                config = settings['hostapd_config']
                setup_bridge = settings.get('setup_bridge', False)
                additional_parameters = settings.get('additional_parameters',
                                                     None)
            else:
                raise TypeError(
                    'Items in hostapd_configs list must either be '
                    'hostapd.HostapdConfig objects or dictionaries.')

            self.log.info(f'Restarting network {config.ssid}')
            self.start_ap(config,
                          setup_bridge=setup_bridge,
                          additional_parameters=additional_parameters)

    def channel_switch(self, identifier, channel_num):
        """Switch to a different channel on the given AP."""
        if identifier not in list(self._aps.keys()):
            raise ValueError(f'Invalid identifier {identifier} given')
        instance = self._aps.get(identifier)
        self.log.info(f'channel switch to channel {channel_num}')
        instance.hostapd.channel_switch(channel_num)

    def get_current_channel(self, identifier):
        """Find the current channel on the given AP."""
        if identifier not in list(self._aps.keys()):
            raise ValueError(f'Invalid identifier {identifier} given')
        instance = self._aps.get(identifier)
        return instance.hostapd.get_current_channel()

    def get_stas(self, identifier) -> Set[str]:
        """Return MAC addresses of all associated STAs on the given AP."""
        if identifier not in list(self._aps.keys()):
            raise ValueError(f'Invalid identifier {identifier} given')
        instance = self._aps.get(identifier)
        return instance.hostapd.get_stas()

    def get_sta_extended_capabilities(self, identifier,
                                      sta_mac: str) -> ExtendedCapabilities:
        """Get extended capabilities for the given STA, as seen by the AP."""
        if identifier not in list(self._aps.keys()):
            raise ValueError(f'Invalid identifier {identifier} given')
        instance = self._aps.get(identifier)
        return instance.hostapd.get_sta_extended_capabilities(sta_mac)

    def send_bss_transition_management_req(
            self, identifier, sta_mac: str,
            request: BssTransitionManagementRequest):
        """Send a BSS Transition Management request to an associated STA."""
        if identifier not in list(self._aps.keys()):
            raise ValueError('Invalid identifier {identifier} given')
        instance = self._aps.get(identifier)
        return instance.hostapd.send_bss_transition_management_req(
            sta_mac, request)