# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging
import time

from autotest_lib.client.common_lib import error
from autotest_lib.server import hosts
from autotest_lib.server import frontend
from autotest_lib.server.cros.dynamic_suite import tools
from autotest_lib.server.cros.dynamic_suite import host_lock_manager

"""
PacketCapture and PacketCapture manager, together, form a mini-suite of code
to capture packets on a specified wifi frequency and high-throughput
configuration (which is either empty or equal to one of "HT20", "HT40+", or
"HT40-".  One would use these classes as follows:

    from autotest_lib.server import packet_capture

    with packet_capture.PacketCaptureManager() as capturer:
        frequency = 5785  # For example.
        try:
            capturer.allocate_packet_capture_machine()
            capturer.start_capture(frequency)

            # Do things.

        except error.TestError as e:
            raise e

        except Exception as e:
            logging.error('Problem: %s', str(e))

        finally:
            capturer.stop_capture()
            capturer.get_capture_file('foo.bar')
"""

class PacketCapture(object):
    """
    Captures packets on a specific WiFi channel for Autotests.

    This is designed to enable Autotest servers to allocate a machine to do
    WiFi packet capture.
    """

    scan_wait_seconds = 0.1

    # TODO(wdg): Add packet capture machines to an access control list.

    def __init__(self):
        self._remote_filename = '/tmp/output.pcap'
        self._iw = 'iw'
        self._ifconfig = 'ifconfig'
        self._tcpdump = 'tcpdump'
        self._monitor_iface = 'mon0'
        self._scan_iface = 'eth_test'  # shill does not manage this iface.
        self._host = None
        self._tcpdump_pid = None
        self._tcpdump_job = None
        self.manager = host_lock_manager.HostLockManager()


    def allocate_packet_capture_machine(self):
        """
        Allocates a machine to capture packets.  Locks it so nobody else can
        use it.

        @raises error.TestError
        """
        afe = frontend.AFE(debug=True)
        hosts_maybe = afe.get_hosts(multiple_labels=['packet_capture'])
        if not hosts_maybe:
            raise error.TestError('No packet capture machines available')
        host_afe = tools.get_random_best_host(afe, hosts_maybe,
                                              require_usable_hosts=True)

        self._host = hosts.SSHHost(host_afe.hostname+'.cros')
        if not self._host:
            raise error.TestError('Could not choose packet capture machine')

        self.manager.add([self._host.hostname])
        self.manager.lock()  # Lock the host so nobody else can use it.


    def _delete_files_and_interfaces(self):
        """Removes packet capture file; deletes interfaces."""
        if self._host is not None:
            self._host.run('rm %s' % self._remote_filename,
                           ignore_status=True)
            self._host.run('%s dev wlan0 del' % self._iw, ignore_status=True)
            self._host.run('%s dev %s del' % (self._iw, self._monitor_iface),
                           ignore_status=True)
            self._host.run('%s dev %s del' % (self._iw, self._scan_iface),
                           ignore_status=True)


    def start_capture(self, freq, ht40=None):
        """
        Configures the packet capture interface and starts capture.

        @param freq: WiFi frequency on which to capture.
        @param ht40: High-Throughput mode (if any) on which to capture.  Legal
                values are 'HT20', 'HT40+', and 'HT40-'.
        """
        # TODO(wdg): May want to enhance this by adding a BSS or SSID
        # parameter to this method (which would be redundant with the
        # frequency and ht mode) and, by scraping an 'iw scan', verifying that
        # that it's working on the frequency and ht configuration specified.

        # Delete wifi interfaces and bring up a monitor interface.
        self._delete_files_and_interfaces()

        if not self._host:
          return

        # TODO(wdg): If this first command fails, mark the machine as broken.
        self._host.run('%s phy0 interface add %s type monitor' %
                       (self._iw, self._monitor_iface))
        self._host.run('%s %s up' % (self._ifconfig, self._monitor_iface))
        self._host.run('%s phy0 interface add %s type managed' %
                       (self._iw, self._scan_iface))
        self._host.run('%s %s up' % (self._ifconfig, self._scan_iface))

        self._freq = freq
        start_cmd = '%s %s set freq %s' % (self._iw, self._monitor_iface,
                                           str(self._freq))
        if ht40:
          if ht40 in ('HT20', 'HT40+', 'HT40-'):
            start_cmd = ' '.join([start_cmd, ht40])
          else:
            logging.error('Illegal ht40 parameter: %s, ignoring', ht40)
        self._host.run(start_cmd)

        # Launch a separate process to do the tcpdump.  Redirection in the
        # command below is necessary, because 'ssh' won't terminate until
        # background child processes close stdin, stdout, and stderr.
        command = '%s -i %s -w %s' % (self._tcpdump, self._monitor_iface,
                                      self._remote_filename)
        remote_cmd = '( %s ) </dev/null >/dev/null 2>&1 & echo $!' % command
        self._host.run(remote_cmd)

        self._assert_capture_ok()


    def _assert_capture_ok(self):
        """
        Force traffic on the previously specified frequency and verify that
        tcpdump is getting something.  Raise an exception if there's a problem.

        @raises error.TestError
        """
        self._host.run('%s %s scan freq %s' % (self._iw, self._scan_iface,
                                               self._freq))
        time.sleep(PacketCapture.scan_wait_seconds)  # Give the scan a moment...
        try:
            self._host.run('ls -l %s' % self._remote_filename)
        except Exception as e:
            logging.error('No output to %s: %s', self._remote_filename, str(e))
            raise error.TestError('tcpdump is not capturing anything')


    def stop_capture(self):
        try:
            self._host.run('killall tcpdump', timeout=30)
        except Exception as e:
            # Don't really care if this didn't run -- this is cleanup.
            pass


    def get_capture_file(self, local_file):
        """
        Retrieves output.pcap.  Puts that file in chroot in:
            /tmp/run_remote_tests.XXXX/testDir/testDir.testName/<local_file>
        """
        if self._host:
            self._host.get_file(self._remote_filename, local_file)


    def done_capturing(self):
        """
        Tries to put things back the way we expected them to be when we got
        here.  Also, releases the packet capture machine so others can use it.
        """
        # Unlock the host to let other people use it.
        self.manager.unlock()
        # Put the wifi interface back in its normal configuration.
        self._delete_files_and_interfaces()
        self._host.run('%s phy0 interface add wlan0 type managed' % self._iw)
        self._host.run('%s wlan0 up' % self._ifconfig)


class PacketCaptureManager(object):
    """
    Context manager to make sure that 'PacketCapture' shuts down properly.
    """
    def __init__(self):
        self._capturer = None
        self._hosts_locked_by = None

    # TODO(milleral): This code needs to be cleaned up once the host locking
    # code is made more usable (see crosbug.com/36072).

    def __enter__(self):
        self._capturer = PacketCapture()
        self._hosts_locked_by = host_lock_manager.HostsLockedBy(
            self._capturer.manager)
        self._hosts_locked_by.__enter__()
        return self._capturer


    def __exit__(self, exit_type, exit_value, exit_traceback):
        if self._hosts_locked_by:
            self._hosts_locked_by.__exit__(exit_type, exit_value,
                                           exit_traceback)
        if self._capturer:
          self._capturer.stop_capture()
          self._capturer.done_capturing()