xref: /aosp_15_r20/external/autotest/client/cros/cellular/pseudomodem/sim.py (revision 9c5db1993ded3edbeafc8092d69fe5de2ee02df7)

# Lint as: python2, python3
# Copyright (c) 2014 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.

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import dbus
import dbus.service
import logging

import six

from autotest_lib.client.cros.cellular import mm1_constants
from autotest_lib.client.cros.cellular.pseudomodem import dbus_std_ifaces
from autotest_lib.client.cros.cellular.pseudomodem import pm_constants
from autotest_lib.client.cros.cellular.pseudomodem import pm_errors
from autotest_lib.client.cros.cellular.pseudomodem import utils

class IncorrectPasswordError(pm_errors.MMMobileEquipmentError):
    """ Wrapper around MM_MOBILE_EQUIPMENT_ERROR_INCORRECT_PASSWORD. """

    def __init__(self):
        pm_errors.MMMobileEquipmentError.__init__(
                self, pm_errors.MMMobileEquipmentError.INCORRECT_PASSWORD,
                'Incorrect password')

class SimPukError(pm_errors.MMMobileEquipmentError):
    """ Wrapper around MM_MOBILE_EQUIPMENT_ERROR_SIM_PUK. """

    def __init__(self):
        pm_errors.MMMobileEquipmentError.__init__(
                self, pm_errors.MMMobileEquipmentError.SIM_PUK,
                'SIM PUK required')

class SimFailureError(pm_errors.MMMobileEquipmentError):
    """ Wrapper around MM_MOBILE_EQUIPMENT_ERROR_SIM_FAILURE. """

    def __init__(self):
        pm_errors.MMMobileEquipmentError.__init__(
                self, pm_errors.MMMobileEquipmentError.SIM_FAILURE,
                'SIM failure')

class SIM(dbus_std_ifaces.DBusProperties):
    """
    Pseudomodem implementation of the org.freedesktop.ModemManager1.Sim
    interface.

    Broadband modems usually need a SIM card to operate. Each Modem object will
    therefore expose up to one SIM object, which allows SIM-specific actions
    such as PIN unlocking.

    The SIM interface handles communication with SIM, USIM, and RUIM (CDMA SIM)
    cards.

    """

    # Multiple object paths needs to be supported so that the SIM can be
    # "reset". This allows the object to reappear on a new path as if it has
    # been reset.
    SUPPORTS_MULTIPLE_OBJECT_PATHS = True

    DEFAULT_MSIN = '1234567890'
    DEFAULT_IMSI = '888999111'
    DEFAULT_PIN = '1111'
    DEFAULT_PUK = '12345678'
    DEFAULT_PIN_RETRIES = 3
    DEFAULT_PUK_RETRIES = 10

    class Carrier:
        """
        Represents a 3GPP carrier that can be stored by a SIM object.

        """
        MCC_LIST = {
            'test' : '001',
            'us': '310',
            'de': '262',
            'es': '214',
            'fr': '208',
            'gb': '234',
            'it': '222',
            'nl': '204'
        }

        CARRIER_LIST = {
            'test' : ('test', '000', pm_constants.DEFAULT_TEST_NETWORK_PREFIX),
            'banana' : ('us', '001', 'Banana-Comm'),
            'att': ('us', '090', 'AT&T'),
            'tmobile': ('us', '026', 'T-Mobile'),
            'simyo': ('de', '03', 'simyo'),
            'movistar': ('es', '07', 'Movistar'),
            'sfr': ('fr', '10', 'SFR'),
            'three': ('gb', '20', '3'),
            'threeita': ('it', '99', '3ITA'),
            'kpn': ('nl', '08', 'KPN')
        }

        def __init__(self, carrier='test'):
           carrier = self.CARRIER_LIST.get(carrier, self.CARRIER_LIST['test'])

           self.mcc = self.MCC_LIST[carrier[0]]
           self.mnc = carrier[1]
           self.operator_name = carrier[2]
           if self.operator_name != 'Banana-Comm':
              self.operator_name = self.operator_name + ' - Fake'
           self.operator_id = self.mcc + self.mnc


    def __init__(self,
                 carrier,
                 access_technology,
                 index=0,
                 pin=DEFAULT_PIN,
                 puk=DEFAULT_PUK,
                 pin_retries=DEFAULT_PIN_RETRIES,
                 puk_retries=DEFAULT_PUK_RETRIES,
                 locked=False,
                 msin=DEFAULT_MSIN,
                 imsi=DEFAULT_IMSI,
                 config=None):
        if not carrier:
            raise TypeError('A carrier is required.')
        path = mm1_constants.MM1 + '/SIM/' + str(index)
        self.msin = msin
        self._carrier = carrier
        self.imsi = carrier.operator_id + imsi
        self._index = 0
        self._total_pin_retries = pin_retries
        self._total_puk_retries = puk_retries
        self._lock_data = {
            mm1_constants.MM_MODEM_LOCK_SIM_PIN : {
                'code' : pin,
                'retries' : pin_retries
            },
            mm1_constants.MM_MODEM_LOCK_SIM_PUK : {
                'code' : puk,
                'retries' : puk_retries
            }
        }
        self._lock_enabled = locked
        self._show_retries = locked
        if locked:
            self._lock_type = mm1_constants.MM_MODEM_LOCK_SIM_PIN
        else:
            self._lock_type = mm1_constants.MM_MODEM_LOCK_NONE
        self._modem = None
        self.access_technology = access_technology
        dbus_std_ifaces.DBusProperties.__init__(self, path, None, config)


    def IncrementPath(self):
        """
        Increments the current index at which this modem is exposed on DBus.
        E.g. if the current path is org/freedesktop/ModemManager/Modem/0, the
        path will change to org/freedesktop/ModemManager/Modem/1.

        Calling this method does not remove the object from its current path,
        which means that it will be available via both the old and the new
        paths. This is currently only used by Reset, in conjunction with
        dbus_std_ifaces.DBusObjectManager.[Add|Remove].

        """
        self._index += 1
        path = mm1_constants.MM1 + '/SIM/' + str(self._index)
        logging.info('SIM coming back as: ' + path)
        self.SetPath(path)


    def Reset(self):
        """ Resets the SIM. This will lock the SIM if locks are enabled. """
        self.IncrementPath()
        if not self.locked and self._lock_enabled:
            self._lock_type = mm1_constants.MM_MODEM_LOCK_SIM_PIN


    @property
    def lock_type(self):
        """
        Returns the current lock type of the SIM. Can be used to determine
        whether or not the SIM is locked.

        @returns: The lock type, as a MMModemLock value.

        """
        return self._lock_type


    @property
    def unlock_retries(self):
        """
        Returns the number of unlock retries left.

        @returns: The number of unlock retries for each lock type the SIM
                supports as a dictionary.

        """
        retries = dbus.Dictionary(signature='uu')
        if not self._show_retries:
            return retries
        for k, v in six.iteritems(self._lock_data):
            retries[dbus.types.UInt32(k)] = dbus.types.UInt32(v['retries'])
        return retries


    @property
    def enabled_locks(self):
        """
        Returns the currently enabled facility locks.

        @returns: The currently enabled facility locks, as a MMModem3gppFacility
                value.

        """
        if self._lock_enabled:
            return mm1_constants.MM_MODEM_3GPP_FACILITY_SIM
        return mm1_constants.MM_MODEM_3GPP_FACILITY_NONE


    @property
    def locked(self):
        """ @returns: True, if the SIM is locked. False, otherwise. """
        return not (self._lock_type == mm1_constants.MM_MODEM_LOCK_NONE or
            self._lock_type == mm1_constants.MM_MODEM_LOCK_UNKNOWN)


    @property
    def modem(self):
        """
        @returns: the modem object that this SIM is currently plugged into.

        """
        return self._modem


    @modem.setter
    def modem(self, modem):
        """
        Assigns a modem object to this SIM, so that the modem knows about it.
        This should only be called directly by a modem object.

        @param modem: The modem to be associated with this SIM.

        """
        self._modem = modem


    @property
    def carrier(self):
        """
        @returns: An instance of SIM.Carrier that contains the carrier
                information assigned to this SIM.

        """
        return self._carrier


    def _DBusPropertiesDict(self):
        imsi = self.imsi
        if self.locked:
            msin = ''
            op_id = ''
            op_name = ''
        else:
            msin = self.msin
            op_id = self._carrier.operator_id
            op_name = self._carrier.operator_name
        return {
            'SimIdentifier' : msin,
            'Imsi' : imsi,
            'OperatorIdentifier' : op_id,
            'OperatorName' : op_name
        }


    def _InitializeProperties(self):
        return { mm1_constants.I_SIM : self._DBusPropertiesDict() }


    def _UpdateProperties(self):
        self.SetAll(mm1_constants.I_SIM, self._DBusPropertiesDict())


    def _CheckCode(self, code, lock_data, next_lock, error_to_raise):
        # Checks |code| against |lock_data['code']|. If the codes don't match:
        #
        #   - if the number of retries left for |lock_data| drops down to 0,
        #     the current lock type gets set to |next_lock| and
        #     |error_to_raise| is raised.
        #
        #   - otherwise, IncorrectPasswordError is raised.
        #
        # If the codes match, no error is raised.

        if code == lock_data['code']:
            # Codes match, nothing to do.
            return

        # Codes didn't match. Figure out which error to raise based on
        # remaining retries.
        lock_data['retries'] -= 1
        self._show_retries = True
        if lock_data['retries'] == 0:
            logging.info('Retries exceeded the allowed number.')
            if next_lock:
                self._lock_type = next_lock
                self._lock_enabled = True
        else:
            error_to_raise = IncorrectPasswordError()
        self._modem.UpdateLockStatus()
        raise error_to_raise


    def _ResetRetries(self, lock_type):
        if lock_type == mm1_constants.MM_MODEM_LOCK_SIM_PIN:
            value = self._total_pin_retries
        elif lock_type == mm1_constants.MM_MODEM_LOCK_SIM_PUK:
            value = self._total_puk_retries
        else:
            raise TypeError('Invalid SIM lock type')
        self._lock_data[lock_type]['retries'] = value


    @utils.log_dbus_method()
    @dbus.service.method(mm1_constants.I_SIM, in_signature='s')
    def SendPin(self, pin):
        """
        Sends the PIN to unlock the SIM card.

        @param pin: A string containing the PIN code.

        """
        if not self.locked:
            logging.info('SIM is not locked. Nothing to do.')
            return

        if self._lock_type == mm1_constants.MM_MODEM_LOCK_SIM_PUK:
            if self._lock_data[self._lock_type]['retries'] == 0:
                raise SimFailureError()
            else:
                raise SimPukError()

        lock_data = self._lock_data.get(self._lock_type, None)
        if not lock_data:
            raise pm_errors.MMCoreError(
                pm_errors.MMCoreError.FAILED,
                'Current lock type does not match the SIM lock capabilities.')

        self._CheckCode(pin, lock_data, mm1_constants.MM_MODEM_LOCK_SIM_PUK,
                        SimPukError())

        logging.info('Entered correct PIN.')
        self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN)
        self._lock_type = mm1_constants.MM_MODEM_LOCK_NONE
        self._modem.UpdateLockStatus()
        self._modem.Expose3GPPProperties()
        self._UpdateProperties()


    @utils.log_dbus_method()
    @dbus.service.method(mm1_constants.I_SIM, in_signature='ss')
    def SendPuk(self, puk, pin):
        """
        Sends the PUK and a new PIN to unlock the SIM card.

        @param puk: A string containing the PUK code.
        @param pin: A string containing the PIN code.

        """
        if self._lock_type != mm1_constants.MM_MODEM_LOCK_SIM_PUK:
            logging.info('No PUK lock in place. Nothing to do.')
            return

        lock_data = self._lock_data.get(self._lock_type, None)
        if not lock_data:
            raise pm_errors.MMCoreError(
                    pm_errors.MMCoreError.FAILED,
                    'Current lock type does not match the SIM locks in place.')

        if lock_data['retries'] == 0:
            raise SimFailureError()

        self._CheckCode(puk, lock_data, None, SimFailureError())

        logging.info('Entered correct PUK.')
        self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN)
        self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PUK)
        self._lock_data[mm1_constants.MM_MODEM_LOCK_SIM_PIN]['code'] = pin
        self._lock_type = mm1_constants.MM_MODEM_LOCK_NONE
        self._modem.UpdateLockStatus()
        self._modem.Expose3GPPProperties()
        self._UpdateProperties()


    @utils.log_dbus_method()
    @dbus.service.method(mm1_constants.I_SIM, in_signature='sb')
    def EnablePin(self, pin, enabled):
        """
        Enables or disables PIN checking.

        @param pin: A string containing the PIN code.
        @param enabled: True to enable PIN, False otherwise.

        """
        if enabled:
            self._EnablePin(pin)
        else:
            self._DisablePin(pin)


    def _EnablePin(self, pin):
        # Operation fails if the SIM is locked or PIN lock is already
        # enabled.
        if self.locked or self._lock_enabled:
            raise SimFailureError()

        lock_data = self._lock_data[mm1_constants.MM_MODEM_LOCK_SIM_PIN]
        self._CheckCode(pin, lock_data, mm1_constants.MM_MODEM_LOCK_SIM_PUK,
                        SimPukError())
        self._lock_enabled = True
        self._show_retries = True
        self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN)
        self._UpdateProperties()
        self.modem.UpdateLockStatus()


    def _DisablePin(self, pin):
        if not self._lock_enabled:
            raise SimFailureError()

        if self.locked:
            self.SendPin(pin)
        else:
            lock_data = self._lock_data[mm1_constants.MM_MODEM_LOCK_SIM_PIN]
            self._CheckCode(pin, lock_data,
                            mm1_constants.MM_MODEM_LOCK_SIM_PUK, SimPukError())
            self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN)
        self._lock_enabled = False
        self._UpdateProperties()
        self.modem.UpdateLockStatus()


    @utils.log_dbus_method()
    @dbus.service.method(mm1_constants.I_SIM, in_signature='ss')
    def ChangePin(self, old_pin, new_pin):
        """
        Changes the PIN code.

        @param old_pin: A string containing the old PIN code.
        @param new_pin: A string containing the new PIN code.

        """
        if not self._lock_enabled or self.locked:
            raise SimFailureError()

        lock_data = self._lock_data[mm1_constants.MM_MODEM_LOCK_SIM_PIN]
        self._CheckCode(old_pin, lock_data,
                        mm1_constants.MM_MODEM_LOCK_SIM_PUK, SimPukError())
        self._ResetRetries(mm1_constants.MM_MODEM_LOCK_SIM_PIN)
        self._lock_data[mm1_constants.MM_MODEM_LOCK_SIM_PIN]['code'] = new_pin
        self._UpdateProperties()
        self.modem.UpdateLockStatus()