# 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 dbus
import dbus.service
import logging
import dbus_std_ifaces
import pm_constants
import pm_errors
import utils
from autotest_lib.client.cros.cellular import mm1_constants
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 self._lock_data.iteritems():
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()