def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
ret_state = STATE.PLUGIN
ret_arg = None
verify_result, remainings = arg_components.modeler.uicc.verify_pin(
PIN_TYPE.ADM1, toBytes(arg_arguments))
# If enabled 'configuration.adm', store the adm code for auto verify
if verify_result == ERROR.NONE:
arg_components.modeler.uicc.adm_verified = True
if arg_components.config.adm == 1:
arg_components.config.update_adm_code(
arg_components.modeler.uicc.iccid, arg_arguments)
else:
if remainings == 0:
ret_state = STATE.ERROR
ret_arg = res.get_string("adm_blocked")
else:
ret_state = STATE.ADM_CODE
ret_arg = res.get_string("incorrect_adm_code").format(
remainings)
log.debug(self.__class__.__name__, "EXIT")
return (ret_state, ret_arg)
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
ret_state = STATE.EXIT
ret_arguments = None
if arg_components.modeler.reader.name == None:
ret_state = STATE.ERROR
ret_arguments = res.get_string("no_cardreader")
else:
ret = arg_components.modeler.open()
if ret == ERROR.CARD_ABSENT:
ret_state = STATE.ERROR
ret_arguments = res.get_string("no_card")
elif ret == ERROR.CARD_INVALID:
ret_state = STATE.ERROR
ret_arguments = res.get_string("invalid_card")
else:
ret_state = STATE.PIN_CODE
out_msg = layout_initial.layout(
res.get_string("reader_connected"),
arg_components.modeler.reader.name)
print(out_msg)
log.debug(self.__class__.__name__, "EXIT")
return (ret_state, ret_arguments)
def help(self):
'''
Returns a help string by 'help' resource key.
If resource not defined 'help' key, will call 'summary()' to instead it.
'''
ret_help = res.get_string("help", self.__class__.__name__)
if ret_help == None:
ret_help = self.summary()
else:
ret_help = ret_help.format(res.get_string("app_name"), self.__class__.__name__)
return ret_help
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
out_msg = layout_startup.layout(arg_name=res.get_string(
'app_name'),
arg_version=res.get_string(
'app_version'),
arg_copyright=res.get_string(
'copyright'))
print(out_msg)
log.debug(self.__class__.__name__, "EXIT")
return (STATE.INITIAL, None)
def execute(self, arg_components: components, arg_arguments=''):
log.debug(self.__class__.__name__, "ENTER")
uicc: uicc = arg_components.modeler.uicc
change_pin1_state_key = None
dict_args = convert_arguments_to_dict(arg_arguments)
for key, value in dict_args.items():
if key == "pin1":
change_pin1_state_key = value
# change pin1 state
if change_pin1_state_key != None:
if is_valid_pin_code(change_pin1_state_key) == False:
print(self.get_res("invalid_pin"))
else:
msg = None
if uicc.pin_enabled:
ret_result, ret_retries = uicc.disable_pin(
toASCIIBytes(change_pin1_state_key))
msg = self.get_res(
'disable_ok') if ret_result == ERROR.NONE else self.get_res('disable_fail')
else:
ret_result, ret_retries = uicc.enable_pin(
toASCIIBytes(change_pin1_state_key))
msg = self.get_res(
'enable_ok') if ret_result == ERROR.NONE else self.get_res('enable_fail')
print(msg)
print(os.linesep, end='')
print(self.get_res("pin1").format(self.get_res("enable"),
res.get_string("yes") if uicc.pin_enabled else res.get_string("no")))
print(self.get_res("pin1").format(self.get_res("verify"),
res.get_string("yes") if uicc.pin_verified else res.get_string("na")))
ret_result, ret_retries = uicc.verify_pin(PIN_TYPE.PIN1, "")
print(self.get_res("pin1").format(self.get_res("retries"), ret_retries))
# space line
print('')
print(self.get_res("adm").format(self.get_res("verify"),
res.get_string("yes") if uicc.adm_verified else res.get_string("no")))
ret_result, ret_retries = uicc.verify_pin(PIN_TYPE.ADM1, "")
print(self.get_res("adm").format(self.get_res("retries"), ret_retries))
log.debug(self.__class__.__name__, "EXIT")
def exec(self):
try:
state_class = __import__("control.state.%s" % (self.__state),
fromlist=[self.__state])
state_instance = getattr(state_class, self.__state)()
log.debug(self.__class__.__name__, self.__state)
self.__state, self.__arguments = state_instance.execute(
self.__components, self.__arguments)
except Exception as e:
error_class = e.__class__.__name__
reason = e.args[0]
cl, exc, tb = sys.exc_info()
lastCallStack = traceback.extract_tb(tb)[-1]
fileName = lastCallStack[0]
lineNum = lastCallStack[1]
funcName = lastCallStack[2]
callstack = os.linesep.join([
line.strip()
for line in traceback.format_exc(limit=5).splitlines()[1:-1]
])
errMsg = res.get_string("exception").format(
os.path.basename(fileName), lineNum, funcName, reason,
callstack)
self.__state = STATE.EXCEPTION
self.__arguments = errMsg
if self.__state == STATE.NONE:
return False
return True
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
out_msg = layout_help.layout(arg_help=res.get_string('help'))
print(out_msg)
log.debug(self.__class__.__name__, "EXIT")
return (STATE.CLI, None)
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
ret_state = STATE.ADM_VERIFY
ret_arg = None
adm_code = None
out_msg = ''
# if 'arg_arguments' exist, means may the auto verify fail
# so we can't read the adm code from .xml file
if arg_arguments == None:
# Auto ADM operation (read from usim_modifier.xml)
adm_code = arg_components.config.query_adm_code(
arg_components.modeler.uicc.iccid)
if adm_code == None:
if arg_arguments == None:
if arg_components.config.admhex == 1:
out_msg = res.get_string("input_adm_code_hex")
else:
out_msg = res.get_string("input_adm_code")
else:
out_msg = arg_arguments
print(layout_adm_code.layout(arg_msg=out_msg), end='')
adm_code = input().strip().upper()
# convert the 8 digits format to 16 hex digit
if arg_components.config.admhex == 0:
adm_code_byte = toASCIIBytes(adm_code)
adm_code = toHexString(adm_code_byte, format=PACK)
if len(adm_code) == 0:
ret_state = STATE.PLUGIN
print(
layout_adm_code.layout(
arg_msg=res.get_string("terminated_adm_code")))
elif not is_valid_adm_code(adm_code):
ret_state = STATE.ADM_CODE
if arg_components.config.admhex == 1:
ret_arg = res.get_string("invalid_adm_code_hex")
else:
ret_arg = res.get_string("invalid_adm_code")
if ret_state == STATE.ADM_VERIFY:
ret_arg = adm_code
log.debug(self.__class__.__name__, "EXIT")
return (ret_state, ret_arg)
def summary(self):
'''
Returns a summary string by 'summary' resource key.
If resource not defined 'help' key, will return 'None', and ignore that.
'''
ret_summary = res.get_string("summary", self.__class__.__name__)
return ret_summary
def execute(self, arg_components: components, arg_arguments):
ret_state = STATE.DISPATCH
ret_arguments = None
log.debug(self.__class__.__name__, "ENTER")
out_msg = layout_cli.layout(arg_prefix=res.get_string('app_name'))
print(out_msg, end='')
ret_arguments = input().strip()
log.debug(self.__class__.__name__, "EXIT")
return (ret_state, ret_arguments)
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
ret_state = STATE.PIN_VERIFY
ret_arg = None
pin_code = None
out_msg = ''
if arg_components.modeler.uicc.pin_enabled == True:
# if 'arg_arguments' exist, means may the auto verify fail.
# so we can't read the pin code from .xml file
if arg_arguments == None:
# Auto PIN operation (read from usim_modifier.xml)
pin_code = arg_components.config.query_pin_code(
arg_components.modeler.uicc.iccid)
if pin_code == None:
if arg_arguments == None:
out_msg = res.get_string("input_pin_code")
else:
out_msg = arg_arguments
print(layout_pin_code.layout(arg_msg=out_msg), end='')
pin_code = input().strip()
if len(pin_code) == 0:
ret_state = STATE.ERROR
ret_arg = res.get_string("terminated_pin_code")
elif not is_valid_pin_code(pin_code):
ret_state = STATE.PIN_CODE
ret_arg = res.get_string("invalid_pin_code")
if ret_state == STATE.PIN_VERIFY:
ret_arg = pin_code
else:
ret_state = STATE.ADM_CODE
log.debug(self.__class__.__name__, "EXIT")
return (ret_state, ret_arg)
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
plugin_class = __import__("model.plugins.%s.%s" %
(arg_arguments, arg_arguments),
fromlist=[arg_arguments])
instance_class = getattr(plugin_class, arg_arguments)()
out_msg = layout_plugin_help.layout(
arg_format=res.get_string('plugin_help_header'),
arg_name=arg_arguments,
arg_help=instance_class.help())
print(out_msg)
log.debug(self.__class__.__name__, "EXIT")
return (STATE.CLI, None)
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
plugins = arg_components.plugin[:]
# check the ADM verify state
# org: plugin name, version, is update adm require
# new: plugin name, version, is updatable
# is_update_require_adm:
# - None: No update feature
# - True: update need adm verified
# - False: Didn't need adm for update
str_yes = res.get_string("yes")
str_no = res.get_string("no")
str_na = res.get_string("na")
for plugin in plugins:
if plugin[3] == None:
plugin[3] = str_na
elif arg_components.modeler.uicc.adm_verified:
plugin[3] = str_yes
else:
plugin[3] = str_yes if plugin[3] == arg_components.modeler.uicc.adm_verified else str_no
if plugin[4]:
plugin[4] = str_yes
else:
plugin[4] = str_no
out_msg = layout_plugin_list.layout(arg_format=res.get_string('plugin_found'),
arg_plugin=plugins)
print(out_msg)
log.debug(self.__class__.__name__, "EXIT")
return (STATE.CLI, None)
def layout(arg_format='', arg_plugin=[]):
# head line
ret_layout = res.get_string("plugin_head").format(
res.get_string("plugin_name"),
res.get_string("plugin_version"),
res.get_string("plugin_update"),
res.get_string("plugin_autoexec"),
res.get_string("plugin_summary")) + os.linesep
ret_layout = layout_oneline.layout(
arg_string=ret_layout, arg_style=STYLE.BRIGHT)
for plugin in arg_plugin:
ret_layout += res.get_string("plugin_item").format(
plugin[0],
plugin[1],
plugin[3],
plugin[4],
plugin[2]) + os.linesep
return ret_layout
def execute(self, arg_components: components, arg_arguments):
log.debug(self.__class__.__name__, "ENTER")
plugin_count = 0
plugin = []
plugins_list = os.listdir("./model/plugins")
for filename in plugins_list:
name, ext = os.path.splitext(filename)
if ext != '.py' and name != '__pycache__' and name != '.DS_Store':
try:
plugin_class = __import__("model.plugins.%s.%s" %
(name, name), fromlist=[name])
res_files = [os.path.join(r, file) for r, d, f in os.walk(
'./model/plugins/%s/values' % (name)) for file in f]
res.add_resource(name, res_files)
instance_class = getattr(plugin_class, name)()
if instance_class.summary() != None:
plugin_count += 1
plugin.append([name,
instance_class.version(),
instance_class.summary(),
instance_class.is_update_require_adm,
instance_class.is_auto_exec])
except:
log.debug(self.__class__.__name__,
"Error to import '%s' plugin." % (name))
arg_components.plugin = plugin
out_msg = layout_plugin.layout(arg_format=res.get_string("plugin_loaded"),
arg_count=plugin_count)
print(out_msg)
log.debug(self.__class__.__name__, "EXIT")
return (STATE.AUTO_EXEC, None)
def get_res(self, arg_resid):
return res.get_string(arg_resid, self.__class__.__name__)
def execute(self, arg_components: components, arg_arguments=''):
log.debug(self.__class__.__name__, "ENTER")
update_log = None
update_localized = None
update_pin = None
update_adm = None
update_autoexec = None
update_admhex = None
dict_args = convert_arguments_to_dict(arg_arguments)
for key, value in dict_args.items():
if key == "log":
update_log = int(value)
elif key == "localized":
update_localized = int(value)
elif key == "pin":
update_pin = int(value)
elif key == "adm":
update_adm = int(value)
elif key == "autoexec":
update_autoexec = int(value)
elif key == "admhex":
update_admhex = int(value)
if update_log != None:
arg_components.config.log = update_log
if update_localized != None:
arg_components.config.localized = update_localized
if update_pin != None:
arg_components.config.pin = update_pin
if update_adm != None:
arg_components.config.adm = update_adm
if update_autoexec != None:
arg_components.config.autoexec = update_autoexec
if update_admhex != None:
arg_components.config.admhex = update_admhex
if update_log != None or update_localized != None or update_pin != None or update_adm != None or update_autoexec != None or update_admhex != None:
arg_components.config.save()
print(
self.get_res("log").format(
res.get_string("yes") if arg_components.config.log ==
1 else res.get_string("no")))
print(
self.get_res("localized").format(
res.get_string("yes") if arg_components.config.localized ==
1 else res.get_string("no")))
print(
self.get_res("pin").format(
res.get_string("yes") if arg_components.config.pin ==
1 else res.get_string("no")))
print(
self.get_res("adm").format(
res.get_string("yes") if arg_components.config.adm ==
1 else res.get_string("no")))
print(
self.get_res("autoexec").format(
res.get_string("yes") if arg_components.config.autoexec ==
1 else res.get_string("no")))
print(
self.get_res("admhex").format(
res.get_string("yes") if arg_components.config.admhex ==
1 else res.get_string("no")))
log.debug(self.__class__.__name__, "EXIT")
