iwd/autotests/util/iwd.py

#!/usr/bin/python3
from gi.repository import GLib

import dbus
import dbus.service
import dbus.mainloop.glib
import sys
import os
import threading
import time
import collections.abc
import datetime
import weakref

from collections.abc import Mapping
from abc import ABCMeta, abstractmethod
from enum import Enum

from config import ctx

IWD_STORAGE_DIR =               '/tmp/iwd'
IWD_CONFIG_DIR =                '/tmp'

DBUS_OBJECT_MANAGER =           'org.freedesktop.DBus.ObjectManager'
DBUS_PROPERTIES =               'org.freedesktop.DBus.Properties'

IWD_SERVICE =                   'net.connman.iwd'
IWD_WIPHY_INTERFACE =           'net.connman.iwd.Adapter'
IWD_AGENT_INTERFACE =           'net.connman.iwd.Agent'
IWD_AGENT_MANAGER_INTERFACE =   'net.connman.iwd.AgentManager'
IWD_DEVICE_INTERFACE =          'net.connman.iwd.Device'
IWD_KNOWN_NETWORK_INTERFACE =   'net.connman.iwd.KnownNetwork'
IWD_NETWORK_INTERFACE =         'net.connman.iwd.Network'
IWD_WSC_INTERFACE =             'net.connman.iwd.SimpleConfiguration'
IWD_SIGNAL_AGENT_INTERFACE =    'net.connman.iwd.SignalLevelAgent'
IWD_AP_INTERFACE =              'net.connman.iwd.AccessPoint'
IWD_ADHOC_INTERFACE =           'net.connman.iwd.AdHoc'
IWD_STATION_INTERFACE =         'net.connman.iwd.Station'
IWD_P2P_INTERFACE =             'net.connman.iwd.p2p.Device'
IWD_P2P_PEER_INTERFACE =        'net.connman.iwd.p2p.Peer'
IWD_P2P_SERVICE_MANAGER_INTERFACE = 'net.connman.iwd.p2p.ServiceManager'
IWD_P2P_WFD_INTERFACE =         'net.connman.iwd.p2p.Display'
IWD_STATION_DEBUG_INTERFACE =   'net.connman.iwd.StationDebug'
IWD_DPP_INTERFACE =             'net.connman.iwd.DeviceProvisioning'
IWD_DPP_PKEX_INTERFACE =        'net.connman.iwd.SharedCodeDeviceProvisioning'
IWD_SHARED_CODE_AGENT_INTERFACE = 'net.connman.iwd.SharedCodeAgent'

IWD_AGENT_MANAGER_PATH =        '/net/connman/iwd'
IWD_TOP_LEVEL_PATH =            '/'

class UnknownDBusEx(Exception): pass
class InProgressEx(dbus.DBusException): pass
class FailedEx(dbus.DBusException): pass
class AbortedEx(dbus.DBusException): pass
class NotAvailableEx(dbus.DBusException): pass
class InvalidArgumentsEx(dbus.DBusException): pass
class InvalidFormatEx(dbus.DBusException): pass
class AlreadyExistsEx(dbus.DBusException): pass
class NotFoundEx(dbus.DBusException): pass
class NotSupportedEx(dbus.DBusException): pass
class NoAgentEx(dbus.DBusException): pass
class NotConnectedEx(dbus.DBusException): pass
class NotConfiguredEx(dbus.DBusException): pass
class NotImplementedEx(dbus.DBusException): pass
class ServiceSetOverlapEx(dbus.DBusException): pass
class AlreadyProvisionedEx(dbus.DBusException): pass
class NotHiddenEx(dbus.DBusException): pass
class CanceledEx(dbus.DBusException):
    _dbus_error_name = 'net.connman.iwd.Error.Canceled'


_dbus_ex_to_py = {
    'Canceled' :            CanceledEx,
    'InProgress' :          InProgressEx,
    'Failed' :              FailedEx,
    'Aborted' :             AbortedEx,
    'NotAvailable' :        NotAvailableEx,
    'InvalidArguments' :    InvalidArgumentsEx,
    'InvalidFormat' :       InvalidFormatEx,
    'AlreadyExists' :       AlreadyExistsEx,
    'NotFound' :            NotFoundEx,
    'NotSupported' :        NotSupportedEx,
    'NoAgent' :             NoAgentEx,
    'NotConnected' :        NotConnectedEx,
    'NotConfigured' :       NotConfiguredEx,
    'NotImplemented' :      NotImplementedEx,
    'ServiceSetOverlap' :   ServiceSetOverlapEx,
    'AlreadyProvisioned' :  AlreadyProvisionedEx,
    'NotHidden' :           NotHiddenEx,
}


def _convert_dbus_ex(dbus_ex):
    ex_name = dbus_ex.get_dbus_name()
    ex_short_name = ex_name[ex_name.rfind(".") + 1:]
    if ex_short_name in _dbus_ex_to_py:
        return _dbus_ex_to_py[ex_short_name](dbus_ex)
    else:
        return UnknownDBusEx(ex_name + ': ' + dbus_ex.get_dbus_message())


class AsyncOpAbstract(object):
    __metaclass__ = ABCMeta

    _is_completed = False
    _exception = None

    def _success(self):
        self._is_completed = True

    def _failure(self, ex):
        self._is_completed = True
        self._exception = _convert_dbus_ex(ex)

    def _wait_for_async_op(self):
        ctx.non_block_wait(lambda s: s._is_completed, 30, self, exception=None)

        self._is_completed = False
        if self._exception is not None:
            tmp = self._exception
            self._exception = None
            raise tmp


class IWDDBusAbstract(AsyncOpAbstract):
    __metaclass__ = ABCMeta

    def __init__(self, object_path = None, properties = None, service=IWD_SERVICE, namespace=ctx):
        self._bus = namespace.get_bus()
        self._namespace = namespace

        self._object_path = object_path
        proxy = self._bus.get_object(service, self._object_path)
        self._iface = dbus.Interface(proxy, self._iface_name)
        self._prop_proxy = dbus.Interface(proxy, DBUS_PROPERTIES)

        if properties is None:
            self._properties = self._prop_proxy.GetAll(self._iface_name)
        else:
            self._properties = properties

        self._prop_proxy.connect_to_signal("PropertiesChanged",
                                           self._property_changed_handler,
                                           DBUS_PROPERTIES,
                                           path_keyword="path")

    def _property_changed_handler(self, interface, changed, invalidated, path):
        if interface == self._iface_name and path == self._object_path:
            for name, value in changed.items():
                self._properties[name] = value

    @abstractmethod
    def __str__(self):
        pass


class DeviceState(Enum):
    '''Conection state of a device'''
    connected =     'connected'
    disconnected =  'disconnected'
    connecting =    'connecting'
    disconnecting = 'disconnecting'
    roaming =       'roaming'

    def __str__(self):
        return self.value

    @classmethod
    def from_str(cls, string):
        return getattr(cls, string, None)


class NetworkType(Enum):
    '''Network security type'''
    open =  'open'
    psk =   'psk'
    eap =   '8021x'
    hotspot = 'hotspot'

    def __str__(self):
        return str(self.value)

    @classmethod
    def from_string(cls, string):
        type = None
        for attr in dir(cls):
            if (str(getattr(cls, attr)) == string):
                type = getattr(cls, attr)
                break
        return type


class SignalAgent(dbus.service.Object):
    def __init__(self, passphrase = None):
        self._path = '/test/agent/' + str(int(round(time.time() * 1000)))

        dbus.service.Object.__init__(self, ctx.get_bus(), self._path)

    @property
    def path(self):
        return self._path

    @dbus.service.method(IWD_SIGNAL_AGENT_INTERFACE,
                         in_signature='o', out_signature='')
    def Release(self, path):
        print("SignalAgent released %s" % path)

    @dbus.service.method(IWD_SIGNAL_AGENT_INTERFACE,
                         in_signature='oy', out_signature='')
    def Changed(self, path, level):
        self.handle_new_level(str(path), int(level))

    @abstractmethod
    def handle_new_level(self, path, level):
        pass

class SharedCodeAgent(dbus.service.Object):
    def __init__(self, codes = {}):
        self._path = '/test/agent/' + str(int(round(time.time() * 1000)))
        self._codes = codes

        dbus.service.Object.__init__(self, ctx.get_bus(), self._path)

    @property
    def path(self):
        return self._path

    @dbus.service.method(IWD_SHARED_CODE_AGENT_INTERFACE,
                         in_signature='', out_signature='')
    def Release(self):
        print("SharedCodeAgent released")

    @dbus.service.method(IWD_SHARED_CODE_AGENT_INTERFACE,
                         in_signature='s', out_signature='')
    def Cancel(self, reason):
        print("SharedCodeAgent canceled (%s)" % reason)

    @dbus.service.method(IWD_SHARED_CODE_AGENT_INTERFACE,
                         in_signature='s', out_signature='s')
    def RequestSharedCode(self, identifier):
        print("SharedCodeAgent request for %s" % identifier)

        code = self._codes.get(identifier, None)
        if not code:
            return NotFoundEx("No code found for %s" % identifier)

        return code

class AdHocDevice(IWDDBusAbstract):
    '''
        Class represents an AdHoc device object: net.connman.iwd.AdHoc
    '''
    _iface_name = IWD_ADHOC_INTERFACE

    @property
    def started(self):
        return self._properties['Started']

    @property
    def connected_peers(self):
        return self._properties['ConnectedPeers']

class StationDebug(IWDDBusAbstract):
    '''
        Class represents net.connman.iwd.StationDebug
    '''
    _iface_name = IWD_STATION_DEBUG_INTERFACE

    def __init__(self, *args, **kwargs):
        self._events = []

        IWDDBusAbstract.__init__(self, *args, **kwargs)

        self._iface.connect_to_signal("Event", self._event_handler)

    def _event_handler(self, event, data):
        self._events.insert(0, (event, data))

    @property
    def autoconnect(self):
        return self._properties['AutoConnect']

    def connect_bssid(self, address):
        self._iface.ConnectBssid(dbus.ByteArray.fromhex(address.replace(':', '')))

    def roam(self, address):
        self._iface.Roam(dbus.ByteArray.fromhex(address.replace(':', '')))

    def scan(self, frequencies):
        frequencies = dbus.Array([dbus.UInt16(f) for f in frequencies])
        self._iface.Scan(frequencies)

    def _poll_event(self, event):
        for idx, e in enumerate(self._events):
            if event == e[0]:
                # Consume any older events
                self._events = self._events[:idx]
                return True

        return False

    def wait_for_event(self, event, timeout=10):
        return ctx.non_block_wait(self._poll_event, timeout, event,
                                    exception=TimeoutError("waiting for event"))

    def event_ocurred(self, event):
        return self._poll_event(event)

class DeviceProvisioning(IWDDBusAbstract):
    '''
        Class represents net.connman.iwd.DeviceProvisioning
    '''
    _iface_name = IWD_DPP_INTERFACE

    def start_enrollee(self):
        return self._iface.StartEnrollee()

    def start_configurator(self, uri=None):
        if uri:
            return self._iface.ConfigureEnrollee(uri)
        else:
            return self._iface.StartConfigurator()

    def stop(self):
        self._iface.Stop()

    @property
    def uri(self):
        return self._properties['URI']

    @property
    def started(self):
        return self._properties['Started']

    @property
    def role(self):
        return self._properties['Role']

class SharedCodeDeviceProvisioning(IWDDBusAbstract):
    _iface_name = IWD_DPP_PKEX_INTERFACE

    def start_enrollee(self, code, identifier=None):
        args = {
            "Code": code
        }

        if identifier:
            args["Identifier"] = identifier

        self._iface.StartEnrollee(args)

    def start_configurator(self, path):
        self._iface.StartConfigurator(dbus.ObjectPath(path))

    def configure_enrollee(self, code, identifier=None):
        args = {
            "Code": code
        }

        if identifier:
            args["Identifier"] = identifier

        self._iface.ConfigureEnrollee(args)

    def stop(self):
        self._iface.Stop()

    @property
    def started(self):
        return self._properties['Started']

    @property
    def role(self):
        return self._properties['Role']

class AccessPointDevice(IWDDBusAbstract):
    '''
        Class represents net.connman.iwd.AccessPoint
    '''
    _iface_name = IWD_AP_INTERFACE

    def start(self, ssid, psk):
        self._iface.Start(ssid, psk, reply_handler=self._success,
                                        error_handler=self._failure)
        self._wait_for_async_op()

        IWD._wait_for_object_condition(self, 'obj.started == True')

    def start_profile(self, ssid):
        self._iface.StartProfile(ssid, reply_handler=self._success,
                                        error_handler=self._failure)
        self._wait_for_async_op()

        IWD._wait_for_object_condition(self, 'obj.started == True')

    def stop(self):
        self._iface.Stop(reply_handler=self._success,
                            error_handler=self._failure)
        self._wait_for_async_op()

        IWD._wait_for_object_condition(self, 'obj.started == False')

    def scan(self):
        self._iface.Scan(reply_handler=self._success,
                                        error_handler=self._failure)
        self._wait_for_async_op()

        IWD._wait_for_object_condition(self, 'obj.scanning == True')
        IWD._wait_for_object_condition(self, 'obj.scanning == False')

    def get_ordered_networks(self):
        return self._iface.GetOrderedNetworks()

    @property
    def started(self):
        return self._properties['Started']

    @property
    def name(self):
        return self._properties['Name']

    @property
    def scanning(self):
        return self._properties['Scanning']

    @property
    def frequency(self):
        return self._properties['Frequency']

    @property
    def pairwise_ciphers(self):
        return self._properties['PairwiseCiphers']

    @property
    def group_cipher(self):
        return self._properties['GroupCipher']


class Device(IWDDBusAbstract):
    '''
        Class represents a network device object: net.connman.iwd.Device
        with its properties and methods
    '''
    _iface_name = IWD_DEVICE_INTERFACE

    def __init__(self, *args, **kwargs):
        self._wps_manager_if = None
        self._station_if = None
        self._station_props = None
        self._station_debug_obj = None
        self._dpp_obj = None
        self._sc_dpp_obj = None
        self._ap_obj = None

        IWDDBusAbstract.__init__(self, *args, **kwargs)

    @property
    def _wps_manager(self):
        if self._wps_manager_if is None:
            _wps_manager_if =\
                dbus.Interface(self._bus.get_object(IWD_SERVICE,
                                                    self.device_path),
                               IWD_WSC_INTERFACE)
        return _wps_manager_if

    @property
    def _station(self):
        if self._station_if is None:
            self._station_if = dbus.Interface(self._bus.get_object(IWD_SERVICE,
                                                            self.device_path),
                                            IWD_STATION_INTERFACE)
        return self._station_if

    @property
    def _device_provisioning(self):
        if self._properties['Mode'] != 'station':
            self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'station')

        if self._dpp_obj is None:
            self._dpp_obj = DeviceProvisioning(object_path=self._object_path,
                                                namespace=self._namespace)

        return self._dpp_obj

    @property
    def _sc_device_provisioning(self):
        if self._properties['Mode'] != 'station':
            self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'station')

        if self._sc_dpp_obj is None:
            self._sc_dpp_obj = SharedCodeDeviceProvisioning(
                                            object_path=self._object_path,
                                            namespace=self._namespace)
        return self._sc_dpp_obj

    @property
    def _station_debug(self):
        if self._properties['Mode'] != 'station':
            self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'station')

        if self._station_debug_obj is None:
            self._station_debug_obj = StationDebug(object_path=self._object_path,
                                                    namespace=self._namespace)

        return self._station_debug_obj

    @property
    def _ap(self):
        if self._properties['Mode'] != 'ap':
            self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'ap')

        if self._ap_obj is None:
            self._ap_obj = AccessPointDevice(object_path=self._object_path,
                                                namespace=self._namespace)

        return self._ap_obj

    def _station_properties(self):
        if self._station_props is not None:
            return self._station_props

        if self._properties['Mode'] != 'station':
            self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'station')

        self._station_prop_if = \
                dbus.Interface(self._bus.get_object(IWD_SERVICE,
                                                            self.device_path),
                                                DBUS_PROPERTIES)

        self._station_props = self._station_prop_if.GetAll(IWD_STATION_INTERFACE)

        self._station_prop_if.connect_to_signal("PropertiesChanged",
                                        self.__station_property_changed_handler,
                                        DBUS_PROPERTIES, path_keyword="path")

        return self._station_props

    def __station_property_changed_handler(self, interface, changed,
                                                            invalidated, path):
        if interface == IWD_STATION_INTERFACE and path == self._object_path:
            for name, value in changed.items():
                self._station_props[name] = value

                if name == 'Mode' and value != 'station':
                    self._station_debug_obj = None

    @property
    def device_path(self):
        '''
            Device's dbus path.

            @rtype: string
        '''
        return self._object_path

    @property
    def name(self):
        '''
            Device's interface name.

            @rtype: string
        '''
        return self._properties['Name']

    @property
    def address(self):
        '''
            Interface's hardware address in the XX:XX:XX:XX:XX:XX format.

            @rtype: string
        '''
        return self._properties['Address']

    @property
    def state(self):
        '''
            Reflects the general network connection state.

            @rtype: object (State)
        '''
        props = self._station_properties()
        return DeviceState.from_str(props['State'])

    @property
    def connected_network(self):
        '''
            net.connman.iwd.Network object representing the
            network the device is currently connected to or to
            which a connection is in progress.

            @rtype: object (Network)
        '''
        props = self._station_properties()
        return props.get('ConnectedNetwork')

    @property
    def powered(self):
        '''
            True if the interface is UP. If false, the device's radio is
            powered down and no other actions can be performed on the device.

            @rtype: boolean
        '''
        return bool(self._properties['Powered'])

    @property
    def scanning(self):
        '''
        Reflects whether the device is currently scanning
        for networks.  For station devices net.connman.iwd.Network
        objects are updated when this property goes from true to false

        @rtype: boolean
        '''
        if self._properties['Mode'] == 'station':
            props = self._station_properties()
            return bool(props['Scanning'])
        else:
            return bool(self._ap.scanning)

    @property
    def autoconnect(self):
        return self._station_debug.autoconnect

    @autoconnect.setter
    def autoconnect(self, value):
        self._station_debug._prop_proxy.Set(IWD_STATION_DEBUG_INTERFACE,
                                            'AutoConnect', value)

    def scan(self, wait=True):
        '''Schedule a network scan.

           Possible exception: BusyEx
                               FailedEx
        '''
        if self._properties['Mode'] == 'station':
            self._iface.Scan(dbus_interface=IWD_STATION_INTERFACE,
                               reply_handler=self._success,
                               error_handler=self._failure)
            if wait:
                self._wait_for_async_op()
        else:
            self._ap.scan()

    def disconnect(self):
        '''Disconnect from the network

           Possible exception: BusyEx
                               FailedEx
                               NotConnectedEx
        '''
        self._iface.Disconnect(dbus_interface=IWD_STATION_INTERFACE,
                               reply_handler=self._success,
                               error_handler=self._failure)

        self._wait_for_async_op()

    def get_ordered_networks(self, scan_if_needed = True, full_scan = False, list = []):
        '''Return the list of networks found in the most recent
           scan, sorted by their user interface importance
           score as calculated by iwd.  If the device is
           currently connected to a network, that network is
           always first on the list, followed by any known
           networks that have been used at least once before,
           followed by any other known networks and any other
           detected networks as the last group.  Within these
           groups the maximum relative signal-strength is the
           main sorting factor.
        '''
        if self._properties['Mode'] == 'ap':
            return self._ap.get_ordered_networks()

        ordered_networks = []
        if not full_scan:
            for bus_obj in self._station.GetOrderedNetworks():
                ordered_network = OrderedNetwork(bus_obj, self._bus, self._namespace)
                ordered_networks.append(ordered_network)

            names = [x.name for x in ordered_networks]

            # all() will always return true if 'list' is empty
            if all(x in names for x in list) and len(names) > 0:
                return ordered_networks
            elif not scan_if_needed:
                return None

        condition = 'not obj.scanning'
        IWD._wait_for_object_condition(self, condition)

        try:
            # Do a full scan if instructed or if hostapd isn't being used
            if full_scan or not ctx.hostapd:
                self.scan()
            else:
                self.debug_scan(ctx.get_frequencies())
        except InProgressEx:
            pass

        condition = 'obj.scanning'
        IWD._wait_for_object_condition(self, condition)
        condition = 'not obj.scanning'
        IWD._wait_for_object_condition(self, condition)

        for bus_obj in self._station.GetOrderedNetworks():
            ordered_network = OrderedNetwork(bus_obj, self._bus, self._namespace)
            ordered_networks.append(ordered_network)

        if len(ordered_networks) > 0:
            return ordered_networks

        return None

    def get_ordered_network(self, network, scan_if_needed = True, full_scan = False):
        '''Returns a single network from ordered network call, or None if the
           network wasn't found. If the network is not found an exception is
           raised, this removes the need to extra asserts in autotests.
        '''
        def wait_for_network(self, network, scan_if_needed, full_scan):
            networks = self.get_ordered_networks(scan_if_needed, full_scan, list=[network])

            if not networks:
                # No point in continuing if we aren't going to re-scan
                if not scan_if_needed:
                    raise Exception("Network %s not found" % network)

                return False

            for n in networks:
                if n.name == network:
                    return n

            return False

        return ctx.non_block_wait(wait_for_network, 30, self, network, scan_if_needed, full_scan,
                                    exception=Exception("Network %s not found" % network))

    def wps_push_button(self):
        self._wps_manager.PushButton(dbus_interface=IWD_WSC_INTERFACE,
                                     reply_handler=self._success,
                                     error_handler=self._failure)
        self._wait_for_async_op()

    def wps_generate_pin(self):
        return self._wps_manager.GeneratePin()

    def wps_start_pin(self, pin):
        self._wps_manager.StartPin(pin, reply_handler=self._success,
                                        error_handler=self._failure)

    def wps_cancel(self):
        self._wps_manager.Cancel(dbus_interface=IWD_WSC_INTERFACE,
                                 reply_handler=self._success,
                                 error_handler=self._failure)
        self._wait_for_async_op()

    def register_signal_agent(self, signal_agent, levels):
        self._station.RegisterSignalLevelAgent(signal_agent.path,
                                        dbus.Array(levels, 'n'),
                                        dbus_interface=IWD_STATION_INTERFACE,
                                        reply_handler=self._success,
                                        error_handler=self._failure)
        self._wait_for_async_op()

    def unregister_signal_agent(self, signal_agent):
        self._station.UnregisterSignalLevelAgent(signal_agent.path,
                                        dbus_interface=IWD_STATION_INTERFACE,
                                        reply_handler=self._success,
                                        error_handler=self._failure)
        self._wait_for_async_op()

    def start_ap(self, ssid, psk=None):
        try:
            self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'ap')
        except Exception as e:
            raise _convert_dbus_ex(e)

        if psk:
            self._ap.start(ssid, psk)
        else:
            self._ap.start_profile(ssid)

    def stop_ap(self):
        self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'station')

        IWD._wait_for_object_condition(self, "obj._properties['Mode'] == 'station'")

    @property
    def group_cipher(self):
        if self._properties['Mode'] != 'ap':
            raise Exception('group_cipher only supported in AP mode')

        return self._ap.group_cipher

    @property
    def pairwise_ciphers(self):
        if self._properties['Mode'] != 'ap':
            raise Exception('pairwise_cipher only supported in AP mode')

        return self._ap.pairwise_ciphers

    def connect_hidden_network(self, name):
        '''Connect to a hidden network
           Possible exception: BusyEx
                               FailedEx
                               InvalidArgumentsEx
                               NotConfiguredEx
                               NotConnectedEx
                               NotFoundEx
                               ServiceSetOverlapEx
        '''
        self._iface.ConnectHiddenNetwork(name,
                               dbus_interface=IWD_STATION_INTERFACE,
                               reply_handler=self._success,
                               error_handler=self._failure)
        self._wait_for_async_op()

    def connect_hidden_network_async(self, name, reply_handler, error_handler):
        '''Connect to a hidden network
           Possible exception: BusyEx
                               FailedEx
                               InvalidArgumentsEx
                               NotConfiguredEx
                               NotConnectedEx
                               NotFoundEx
                               ServiceSetOverlapEx
        '''
        self._iface.ConnectHiddenNetwork(name,
                               dbus_interface=IWD_STATION_INTERFACE,
                               reply_handler=reply_handler,
                               error_handler=error_handler)

    def start_adhoc(self, ssid, psk=None):
        self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'ad-hoc')
        self._adhoc_iface = dbus.Interface(self._bus.get_object(IWD_SERVICE,
                                            self.device_path),
                                            IWD_ADHOC_INTERFACE)
        if not psk:
            self._adhoc_iface.StartOpen(ssid, reply_handler=self._success,
                                        error_handler=self._failure)
        else:
            self._adhoc_iface.Start(ssid, psk, reply_handler=self._success,
                                        error_handler=self._failure)
        self._wait_for_async_op()

        return AdHocDevice(self.device_path)

    def stop_adhoc(self):
        self._prop_proxy.Set(IWD_DEVICE_INTERFACE, 'Mode', 'station')

    def connect_bssid(self, address):
        self._station_debug.connect_bssid(address)

    def roam(self, address):
        self._station_debug.roam(address)

    def debug_scan(self, frequencies):
        self._station_debug.scan(frequencies)

    def wait_for_event(self, event, timeout=10):
        self._station_debug.wait_for_event(event, timeout)

    def event_ocurred(self, event):
        return self._station_debug.event_ocurred(event)

    def dpp_start_enrollee(self):
        ret = self._device_provisioning.start_enrollee()

        condition = 'obj.started == True'
        IWD._wait_for_object_condition(self._device_provisioning, condition)
        condition = 'obj.role == "enrollee"'
        IWD._wait_for_object_condition(self._device_provisioning, condition)

        return ret

    def dpp_start_configurator(self, uri=None):
        ret = self._device_provisioning.start_configurator(uri)

        condition = 'obj.started == True'
        IWD._wait_for_object_condition(self._device_provisioning, condition)
        condition = 'obj.role == "configurator"'
        IWD._wait_for_object_condition(self._device_provisioning, condition)

        return ret

    def dpp_pkex_enroll(self, *args, **kwargs):
        ret = self._sc_device_provisioning.start_enrollee(*args, **kwargs)

        condition = 'obj.started == True'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)
        condition = 'obj.role == "enrollee"'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)

        return ret

    def dpp_pkex_start_configurator(self, *args, **kwargs):
        ret = self._sc_device_provisioning.start_configurator(*args, **kwargs)

        condition = 'obj.started == True'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)
        condition = 'obj.role == "configurator"'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)

        return ret

    def dpp_pkex_configure_enrollee(self, *args, **kwargs):
        ret = self._sc_device_provisioning.configure_enrollee(*args, **kwargs)

        condition = 'obj.started == True'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)
        condition = 'obj.role == "configurator"'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)

        return ret

    def dpp_pkex_stop(self):
        ret = self._sc_device_provisioning.stop()

        condition = 'obj.started == False'
        IWD._wait_for_object_condition(self._sc_device_provisioning, condition)

        return ret

    def dpp_pkex_register_agent(self, path):
        self._sc_device_provisioning.register_agent(path)

    def dpp_pkex_unregister_agent(self):
        self._sc_device_provisioning.unregister_agent()

    def dpp_stop(self):
        ret = self._device_provisioning.stop()

        condition = 'obj.started == False'
        IWD._wait_for_object_condition(self._device_provisioning, condition)

        return ret

    def __str__(self, prefix = ''):
        s = prefix + 'Device: ' + self.device_path + '\n'\
               + prefix + '\tName:\t\t' + self.name + '\n'\
               + prefix + '\tAddress:\t' + self.address + '\n' \
               + prefix + '\tPowered:\t' + str(self.powered) + '\n'\
               + prefix + '\tMode:\t\t' + self._properties['Mode'] + '\n'

        if self._properties['Mode'] == 'station':
            s += prefix + '\tState:\t\t' + str(self.state) + '\n'\
               + prefix + '\tConnected net:\t' + str(self.connected_network) + '\n'

        return s

class Network(IWDDBusAbstract):
    '''Class represents a network object: net.connman.iwd.Network'''
    _iface_name = IWD_NETWORK_INTERFACE

    @property
    def name(self):
        '''
            Network SSID.

            @rtype: string
        '''
        return self._properties['Name']

    @property
    def connected(self):
        '''
            Reflects whether the device is connected to this network.

            @rtype: boolean
        '''
        return bool(self._properties['Connected'])

    def connect(self, wait=True):
        '''
            Connect to the network. Request the device implied by the object
            path to connect to specified network.

            Possible exception: AbortedEx
                                BusyEx
                                FailedEx
                                NoAgentEx
                                NotSupportedEx
                                TimeoutEx

            @rtype: void
        '''

        self._iface.Connect(dbus_interface=self._iface_name,
                            reply_handler=self._success,
                            error_handler=self._failure)

        if wait:
            self._wait_for_async_op()

    def __str__(self, prefix = ''):
        return prefix + 'Network:\n' \
                + prefix + '\tName:\t' + self.name + '\n' \
                + prefix + '\tConnected:\t' + str(self.connected)


class KnownNetwork(IWDDBusAbstract):
    '''Class represents a known network object: net.connman.iwd.KnownNetwork'''
    _iface_name = IWD_KNOWN_NETWORK_INTERFACE

    def forget(self):
        '''
        Removes information saved by IWD about this network
        causing it to be treated as if IWD had never connected
        to it before.
        '''
        self._iface.Forget(dbus_interface=self._iface_name,
                               reply_handler=self._success,
                               error_handler=self._failure)
        self._wait_for_async_op()

    @property
    def name(self):
        '''Contains the Name (SSID) of the network.'''
        return str(self._properties['Name'])

    @property
    def type(self):
        '''Contains the type of the network.'''
        return NetworkType(self._properties['Type'])

    @property
    def last_connected_time(self):
        '''
        Contains the last time this network has been connected to.
        If the network is known, but has never been successfully
        connected to, this attribute is set to None.

        @rtype: datetime
        '''
        if 'LastConnectedTime' not in self._properties:
            return None

        val = self._properties['LastConnectedTime']
        return datetime.datetime.strptime(val, "%Y-%m-%dT%H:%M:%SZ")

    def __str__(self, prefix = ''):
        return prefix + 'Known Network:\n' \
                + prefix + '\tName:\t' + self.name + '\n' \
                + prefix + '\tType:\t' + str(self.type) + '\n' \
                + prefix + '\tLast connected:\t' + str(self.last_connected_time)

class OrderedNetwork(object):
    '''Represents a network found in the scan'''

    def __init__(self, o_n_tuple, bus, namespace=ctx):
        self._bus = bus
        self._network_object = Network(o_n_tuple[0], namespace=namespace)
        self._network_proxy = dbus.Interface(self._bus.get_object(IWD_SERVICE,
                                        o_n_tuple[0]),
                                        DBUS_PROPERTIES)
        self._properties = self._network_proxy.GetAll(IWD_NETWORK_INTERFACE)

        self._name = self._properties['Name']
        self._signal_strength = o_n_tuple[1]
        self._type = NetworkType.from_string(str(self._properties['Type']))

    @property
    def network_object(self):
        '''
            net.connman.iwd.Network object representing the network.

            @rtype: Network
        '''
        return self._network_object

    @property
    def name(self):
        '''
            Device's interface name.

            @rtype: string
        '''
        return self._name

    @property
    def signal_strength(self):
        '''
            Network's maximum signal strength expressed in 100 * dBm.
            The value is the range of 0 (strongest signal) to
            -10000 (weakest signal)

            @rtype: number
        '''
        return self._signal_strength

    @property
    def type(self):
        '''
            Contains the type of the network.

            @rtype: NetworkType
        '''
        return self._type

    def __str__(self):
        return 'Ordered Network:\n'\
                '\tName:\t\t' + self._name + '\n'\
                '\tNetwork Type:\t' + str(self._type) + '\n'\
                '\tSignal Strength:'\
                    + ('None' if self.signal_strength is None else\
                        str(self.signal_strength)) + '\n'\
                '\tObject: \n' + self.network_object.__str__('\t\t')

agent_count = 0

class PSKAgent(dbus.service.Object):

    def __init__(self, passphrases=[], users=[], namespace=ctx):
        global agent_count

        if type(passphrases) != list:
            passphrases = [passphrases]
        self.passphrases = passphrases
        if type(users) != list:
            users = [users]
        self.users = users
        self._path = '/test/agent/%s' % agent_count
        self._bus = dbus.bus.BusConnection(address_or_type=namespace.dbus_address)

        agent_count += 1

        dbus.service.Object.__init__(self, self._bus, self._path)

    @property
    def path(self):
        return self._path

    @dbus.service.method(IWD_AGENT_INTERFACE, in_signature='', out_signature='')
    def Release(self):
        print("Agent released")

    @dbus.service.method(IWD_AGENT_INTERFACE, in_signature='s',
                                                               out_signature='')
    def Cancel(self, reason):
        print("Cancel: " + reason)


    @dbus.service.method(IWD_AGENT_INTERFACE, in_signature='o',
                                                              out_signature='s')
    def RequestPassphrase(self, path):
        print('Requested PSK for ' + path)

        if not self.passphrases:
            raise CanceledEx("canceled")

        return self.passphrases.pop(0)

    @dbus.service.method(IWD_AGENT_INTERFACE, in_signature='o',
                                                              out_signature='s')
    def RequestPrivateKeyPassphrase(self, path):
        print('Requested private-key passphrase for ' + path)

        if not self.passphrases:
            raise CanceledEx("canceled")

        return self.passphrases.pop(0)

    @dbus.service.method(IWD_AGENT_INTERFACE, in_signature='o',
                                                             out_signature='ss')
    def RequestUserNameAndPassword(self, path):
        print('Requested the user name and password for ' + path)

        if not self.users:
            raise CanceledEx("canceled")

        return self.users.pop(0)

    @dbus.service.method(IWD_AGENT_INTERFACE, in_signature='os',
                                                              out_signature='s')
    def RequestUserPassword(self, path, req_user):
        print('Requested the password for ' + path + ' for user ' + req_user)

        if not self.users:
            raise CanceledEx("canceled")

        user, passwd = self.users.pop(0)
        if user != req_user:
            raise CanceledEx("canceled")

        return passwd


class P2PDevice(IWDDBusAbstract):
    _iface_name = IWD_P2P_INTERFACE

    def __init__(self, *args, **kwargs):
        self._discovery_request = False
        self._peer_dict = {}
        IWDDBusAbstract.__init__(self, *args, **kwargs)

    @property
    def name(self):
        return str(self._properties['Name'])

    @name.setter
    def name(self, name):
        self._prop_proxy.Set(self._iface_name, 'Name', name)

    @property
    def enabled(self):
        return bool(self._properties['Enabled'])

    @enabled.setter
    def enabled(self, enabled):
        self._prop_proxy.Set(self._iface_name, 'Enabled', enabled)

    @property
    def discovery_request(self):
        return self._discovery_request

    @discovery_request.setter
    def discovery_request(self, req):
        if self._discovery_request == bool(req):
            return

        if bool(req):
            self._iface.RequestDiscovery()
        else:
            self._iface.ReleaseDiscovery()

        self._discovery_request = bool(req)

    def get_peers(self):
        old_dict = self._peer_dict
        self._peer_dict = {}

        for path, rssi in self._iface.GetPeers():
            self._peer_dict[path] = old_dict[path] if path in old_dict else P2PPeer(path, namespace=self._namespace)
            self._peer_dict[path].rssi = rssi

        return self._peer_dict


class P2PPeer(IWDDBusAbstract):
    _iface_name = IWD_P2P_PEER_INTERFACE

    @property
    def name(self):
        return str(self._properties['Name'])

    @property
    def category(self):
        return str(self._properties['DeviceCategory'])

    @property
    def subcategory(self):
        return str(self._properties['DeviceSubcategory'])

    @property
    def connected(self):
        return bool(self._properties['Connected'])

    @property
    def connected_interface(self):
        return str(self._properties['ConnectedInterface'])

    @property
    def connected_ip(self):
        return str(self._properties['ConnectedIP'])

    def connect(self, wait=True, pin=None):
        if pin is None:
            self._iface.PushButton(dbus_interface=IWD_WSC_INTERFACE,
                            reply_handler=self._success,
                            error_handler=self._failure)
        else:
            self._iface.StartPin(pin,
                            dbus_interface=IWD_WSC_INTERFACE,
                            reply_handler=self._success,
                            error_handler=self._failure)

        if wait:
            self._wait_for_async_op()
            return (self.connected_interface, self.connected_ip)

    def disconnect(self):
        self._iface.Disconnect()


class DeviceList(Mapping):
    def __init__(self, iwd):
        self._dict = {}
        self._p2p_dict = {}
        self._namespace = iwd.namespace

        iwd._object_manager.connect_to_signal("InterfacesAdded",
                                               self._interfaces_added_handler)
        iwd._object_manager.connect_to_signal("InterfacesRemoved",
                                               self._interfaces_removed_handler)

        objects = iwd._object_manager.GetManagedObjects()

        for path in objects:
            for interface in objects[path]:
                if interface == IWD_DEVICE_INTERFACE:
                    self._dict[path] = Device(path, objects[path][interface],
                                                namespace=self._namespace)
                elif interface == IWD_P2P_INTERFACE:
                    self._p2p_dict[path] = P2PDevice(path, objects[path][interface],
                                                namespace=self._namespace)

    def __getitem__(self, key):
        return self._dict.__getitem__(key)

    def __iter__(self):
        return self._dict.__iter__()

    def __len__(self):
        return self._dict.__len__()

    def __delitem__(self, key):
        self._dict.pop(key).remove()

    def _interfaces_added_handler(self, path, interfaces):
        if IWD_DEVICE_INTERFACE in interfaces:
            self._dict[path] = Device(path, interfaces[IWD_DEVICE_INTERFACE],
                                            namespace=self._namespace)
        elif IWD_P2P_INTERFACE in interfaces:
            self._p2p_dict[path] = P2PDevice(path, interfaces[IWD_P2P_INTERFACE],
                                            namespace=self._namespace)

    def _interfaces_removed_handler(self, path, interfaces):
        if IWD_DEVICE_INTERFACE in interfaces:
            del self._dict[path]
        elif IWD_P2P_INTERFACE in interfaces:
            del self._p2p_dict[path]

    @property
    def p2p_dict(self):
        return self._p2p_dict


class IWD(AsyncOpAbstract):
    '''
        Start an IWD instance. By default IWD should already be running, but
        some tests do require starting IWD using this constructor (by passing
        start_iwd_daemon=True)
    '''
    _default_instance = None

    def __init__(self, start_iwd_daemon = False, iwd_config_dir = '/tmp',
                            iwd_storage_dir = IWD_STORAGE_DIR, namespace=ctx,
                            developer_mode = True):
        self.namespace = namespace
        self._bus = namespace.get_bus()
        self._object_manager_if = None
        self._iwd_proc = None

        if start_iwd_daemon:
            if self.namespace.is_process_running('iwd'):
                raise Exception("IWD requested to start but is already running")

            self._iwd_proc = self.namespace.start_iwd(iwd_config_dir,
                                                        iwd_storage_dir,
                                                        developer_mode)

        self._devices = DeviceList(self)

        # Weak to make sure the test's reference to @self is the only counted
        # reference so that __del__ gets called when it's released. This is only
        # done for the root namespace in order to allow testutil to function
        # correctly in non-namespace tests.
        if self.namespace.name is None:
            IWD._default_instance = weakref.ref(self)

        self.psk_agents = []

    def stop(self):
        if self.namespace.is_process_running('iwd'):
            self._iwd_proc.kill()

    def __del__(self):
        for agent in self.psk_agents:
            self.unregister_psk_agent(agent)

        self.psk_agents = []

        self._object_manager_if = None
        self._known_networks = None
        self._devices = None

        if self._iwd_proc is not None:
            self.namespace.stop_process(self._iwd_proc)
            self._iwd_proc = None

        self.namespace = None

    @property
    def _object_manager(self):
        if self._object_manager_if is None:
            self._object_manager_if = \
                       dbus.Interface(self._bus.get_object(IWD_SERVICE,
                                                           IWD_TOP_LEVEL_PATH),
                                      DBUS_OBJECT_MANAGER)
        return self._object_manager_if

    @staticmethod
    def _wait_for_object_condition(obj, condition_str, max_wait = 50):
        def _eval_wrap(obj, condition_str):
            return eval(condition_str)

        ctx.non_block_wait(_eval_wrap, max_wait, obj, condition_str,
                            exception=TimeoutError('[' + condition_str + ']'\
                                                   ' condition was not met in '\
                                                   + str(max_wait) + ' sec'))

    def wait_for_object_condition(self, *args, **kwargs):
        self._wait_for_object_condition(*args, **kwargs)

    def wait_for_object_change(self, obj, from_str, to_str, max_wait = 50):
        '''
            Wait for 'from_str' to evaluate true then waits for 'to_str'. If
            at any point during the wait 'from_str' evaluates false, an exception is
            raised.

            This allows an object to be checked for a state transition without any
            intermediate state changes.
        '''
        def _eval_from_to(obj, from_str, to_str):
            # If neither the initial or expected condition evaluate the
            # object must be in another unexpected state.
            if not eval(from_str) and not eval(to_str):
                raise Exception('unexpected condition between [%s] and [%s]' %
                                        (from_str, to_str))

            # Initial condition does not evaluate but expected does, pass
            if not eval(from_str) and eval(to_str):
                return True

            return False

        # wait for initial condition
        self._wait_for_object_condition(obj, from_str)

        ctx.non_block_wait(_eval_from_to, max_wait, obj, from_str, to_str,
                            exception=TimeoutError('[' + to_str + ']'\
                                       ' condition was not met in '\
                                       + str(max_wait) + ' sec'))

    @staticmethod
    def wait(time):
        ctx.non_block_wait(lambda : False, time, exception=False)

    @staticmethod
    def clear_storage(storage_dir=IWD_STORAGE_DIR):
        os.system('rm -rf ' + storage_dir + '/*')
        os.system('rm -rf ' + storage_dir + '/hotspot/*')
        os.system('rm -rf ' + storage_dir + '/ap/*')

    @staticmethod
    def create_in_storage(file_name, file_content, storage_dir=IWD_STORAGE_DIR):
        fo = open(storage_dir + '/' + file_name, 'w')

        fo.write(file_content)
        fo.close()

    @staticmethod
    def _ensure_storage_dir_exists(storage_dir):
        if not os.path.exists(storage_dir):
            os.mkdir(storage_dir)

    @staticmethod
    def copy_to_storage(source, storage_dir=IWD_STORAGE_DIR, name=None):
        import shutil

        assert not os.path.isabs(source)

        target = storage_dir
        if name:
            target += '/%s' % name

        IWD._ensure_storage_dir_exists(storage_dir)
        shutil.copy(source, target)

    @staticmethod
    def copy_to_hotspot(source, storage_dir=IWD_STORAGE_DIR):
        IWD._ensure_storage_dir_exists(storage_dir)

        if not os.path.exists(storage_dir + "/hotspot"):
            os.mkdir(storage_dir + "/hotspot")

        IWD.copy_to_storage(source, storage_dir + "/hotspot")

    @staticmethod
    def copy_to_ap(source, storage_dir=IWD_STORAGE_DIR):
        if not os.path.exists(storage_dir + "/ap"):
            os.mkdir(storage_dir + "/ap")

        IWD.copy_to_storage(source, storage_dir + '/ap/')

    @staticmethod
    def remove_from_storage(file_name, storage_dir=IWD_STORAGE_DIR):
        os.system('rm -rf ' + storage_dir + '/\'' + file_name + '\'')

    def list_devices(self, wait_to_appear = 0, max_wait = 50, p2p = False):
        if not wait_to_appear:
            return list(self._devices.values() if not p2p else self._devices.p2p_dict.values())

        ctx.non_block_wait(lambda s, n: len(s._devices) >= n, max_wait, self, wait_to_appear,
                            exception=TimeoutError('IWD has no associated devices'))

        return list(self._devices.values() if not p2p else self._devices.p2p_dict.values())[:wait_to_appear]

    def list_p2p_devices(self, *args, **kwargs):
        return self.list_devices(*args, **kwargs, p2p=True)

    def list_known_networks(self):
        '''Returns the list of KnownNetwork objects.'''
        objects = self._object_manager.GetManagedObjects()
        known_network_list = []

        for path in objects:
            for interface in objects[path]:
                if interface == IWD_KNOWN_NETWORK_INTERFACE:
                    known_network_list.append(
                            KnownNetwork(path, objects[path][interface]))

        return known_network_list

    def register_psk_agent(self, psk_agent):
        iface = dbus.Interface(psk_agent._bus.get_object(IWD_SERVICE,
                                                IWD_AGENT_MANAGER_PATH),
                                                IWD_AGENT_MANAGER_INTERFACE)
        iface.RegisterAgent(psk_agent.path,
                            dbus_interface=IWD_AGENT_MANAGER_INTERFACE,
                            reply_handler=self._success,
                            error_handler=self._failure)

        self._wait_for_async_op()
        self.psk_agents.append(psk_agent)

    def unregister_psk_agent(self, psk_agent):
        iface = dbus.Interface(psk_agent._bus.get_object(IWD_SERVICE,
                                                IWD_AGENT_MANAGER_PATH),
                                                IWD_AGENT_MANAGER_INTERFACE)
        iface.UnregisterAgent(psk_agent.path,
                                dbus_interface=IWD_AGENT_MANAGER_INTERFACE,
                                reply_handler=self._success,
                                error_handler=self._failure)
        self._wait_for_async_op()
        self.psk_agents.remove(psk_agent)

    @staticmethod
    def get_instance():
        return IWD._default_instance()