7:27 a.m.
Hi all,
Here is my 3rd stab at the ofono_sim_ready_notify().
I've generalized the role of ofono_sim_ready_notify(): it is expected
after query_passwd_state returns the CME error 14 (SIM busy). It can be
used before or after PIN/PUK checks.
When ofono_sim_ready_notify() is invoked, it checks that the call is
expected and if so, retries the query_passwd_state.
The patches has now been tested with the PIN and PUK codes with mbm and
the new isimodem sim driver by Jukka Saunamaki.
The isimodem driver demonstrates also the case where PIN is disabled but
SIM is not ready yet when oFono tries to initialize the modem. The
isimodem driver tries to read some CPHS information in order to
determine if the modem is ready.
--Pekka
7:27 a.m.
New subject: [sim-ready-v2 PATCH 1/3] sim: add ofono_sim_ready_notify
From: Pekka Pessi <Pekka.Pessi(a)nokia.com>
The ofono_sim_driver indicates that SIM is not ready with CME error 14
(SIM is busy) in query_passwd_state callback. The sim atom then stops
initializing itself and waits for a call to ofono_sim_ready_notify().
Note that ofono_sim_ready_notify() can be used both before and after
entering the PIN/PUK code.
Based on patches by Kristen Accardi and Denis Kenzior.
---
include/sim.h | 2 ++
src/sim.c | 30 ++++++++++++++++++++++++++++++
2 files changed, 32 insertions(+), 0 deletions(-)
diff --git a/include/sim.h b/include/sim.h
index 7860e24..f4171d1 100644
--- a/include/sim.h
+++ b/include/sim.h
@@ -188,6 +188,8 @@ enum ofono_sim_state ofono_sim_get_state(struct ofono_sim *sim);
void ofono_sim_inserted_notify(struct ofono_sim *sim, ofono_bool_t inserted);
+void ofono_sim_ready_notify(struct ofono_sim *sim);
+
/* This will queue an operation to read all available records with id from the
* SIM. Callback cb will be called every time a record has been read, or once
* if an error has occurred. For transparent files, the callback will only
diff --git a/src/sim.c b/src/sim.c
index e5e304c..294c1a8 100644
--- a/src/sim.c
+++ b/src/sim.c
@@ -45,6 +45,8 @@
#include "simfs.h"
#include "stkutil.h"
+#define SIM_FLAG_WAIT_FOR_READY 0x1
+
static GSList *g_drivers = NULL;
static void sim_own_numbers_update(struct ofono_sim *sim);
@@ -74,6 +76,7 @@ struct ofono_sim {
unsigned char efsst_length;
gboolean fixed_dialing;
gboolean barred_dialing;
+ guint flags;
char *imsi;
@@ -1562,6 +1565,13 @@ static void sim_pin_query_cb(const struct ofono_error *error,
const char *path = __ofono_atom_get_path(sim->atom);
const char *pin_name;
+ if (error->type == OFONO_ERROR_TYPE_CME && error->error == 14) {
+ DBG("SIM not ready");
+ /* Wait for ofono_sim_ready_notify() */
+ sim->flags |= SIM_FLAG_WAIT_FOR_READY;
+ return;
+ }
+
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
ofono_error("Querying PIN authentication state failed");
@@ -1600,6 +1610,24 @@ static void sim_pin_check(struct ofono_sim *sim)
sim->driver->query_passwd_state(sim, sim_pin_query_cb, sim);
}
+void ofono_sim_ready_notify(struct ofono_sim *sim)
+{
+ DBG("");
+
+ if (sim == NULL)
+ return;
+
+ if (sim->state != OFONO_SIM_STATE_INSERTED)
+ return;
+
+ if (!(sim->flags & SIM_FLAG_WAIT_FOR_READY))
+ return;
+
+ sim->flags &= ~SIM_FLAG_WAIT_FOR_READY;
+
+ sim_pin_check(sim);
+}
+
static void sim_efli_read_cb(int ok, int length, int record,
const unsigned char *data,
int record_length, void *userdata)
@@ -2007,6 +2035,8 @@ static void sim_free_state(struct ofono_sim *sim)
sim->fixed_dialing = FALSE;
sim->barred_dialing = FALSE;
+
+ sim->flags = 0;
}
void ofono_sim_inserted_notify(struct ofono_sim *sim, ofono_bool_t inserted)
--
1.7.1
7:27 a.m.
New subject: [sim-ready-v2 PATCH 2/3] isimodem/sim: added PIN and SIM state handling
From: Jukka Saunamaki <jukka.saunamaki(a)nokia.com>
Using ofono_sim_ready_notify().
---
drivers/isimodem/debug.c | 30 +++
drivers/isimodem/debug.h | 3 +
drivers/isimodem/sim.c | 563 +++++++++++++++++++++++++++++++++++++++++++---
drivers/isimodem/sim.h | 50 ++++-
4 files changed, 612 insertions(+), 34 deletions(-)
diff --git a/drivers/isimodem/debug.c b/drivers/isimodem/debug.c
index c724b41..f649b9d 100644
--- a/drivers/isimodem/debug.c
+++ b/drivers/isimodem/debug.c
@@ -48,6 +48,7 @@ const char *pn_resource_name(int value)
_(PN_CALL);
_(PN_SMS);
_(PN_SIM);
+ _(PN_SECURITY);
_(PN_MTC);
_(PN_GSS);
_(PN_GPDS);
@@ -377,18 +378,41 @@ const char *sim_message_id_name(enum sim_message_id value)
_(SIM_IMSI_RESP_READ_IMSI);
_(SIM_SERV_PROV_NAME_REQ);
_(SIM_SERV_PROV_NAME_RESP);
+ _(SIM_DYNAMIC_FLAGS_REQ);
+ _(SIM_DYNAMIC_FLAGS_RESP);
_(SIM_READ_FIELD_REQ);
_(SIM_READ_FIELD_RESP);
_(SIM_SMS_REQ);
_(SIM_SMS_RESP);
+ _(SIM_STATUS_REQ);
+ _(SIM_STATUS_RESP);
_(SIM_PB_REQ_SIM_PB_READ);
_(SIM_PB_RESP_SIM_PB_READ);
+ _(SIM_SERVER_READY_IND);
_(SIM_IND);
_(SIM_COMMON_MESSAGE);
}
return "SIM_<UNKNOWN>";
}
+const char *sec_message_id_name(enum sec_message_id value)
+{
+ switch (value) {
+ _(SEC_CODE_STATE_REQ);
+ _(SEC_CODE_STATE_OK_RESP);
+ _(SEC_CODE_STATE_FAIL_RESP);
+ _(SEC_CODE_CHANGE_REQ);
+ _(SEC_CODE_CHANGE_OK_RESP);
+ _(SEC_CODE_CHANGE_FAIL_RESP);
+ _(SEC_CODE_VERIFY_REQ);
+ _(SEC_CODE_VERIFY_OK_RESP);
+ _(SEC_CODE_VERIFY_FAIL_RESP);
+ _(SEC_STATE_REQ);
+ _(SEC_STATE_RESP);
+ }
+ return "SEC_<UNKNOWN>";
+}
+
const char *sim_subblock_name(enum sim_subblock value)
{
switch (value) {
@@ -1069,6 +1093,12 @@ void sim_debug(const void *restrict buf, size_t len, void *data)
hex_dump(sim_message_id_name(m[0]), m, len);
}
+void sec_debug(const void *restrict buf, size_t len, void *data)
+{
+ const uint8_t *m = buf;
+ hex_dump(sec_message_id_name(m[0]), m, len);
+}
+
void info_debug(const void *restrict buf, size_t len, void *data)
{
const uint8_t *m = buf;
diff --git a/drivers/isimodem/debug.h b/drivers/isimodem/debug.h
index dbdc4de..0127010 100644
--- a/drivers/isimodem/debug.h
+++ b/drivers/isimodem/debug.h
@@ -49,6 +49,8 @@ const char *sim_isi_cause_name(enum sim_isi_cause value);
const char *sim_message_id_name(enum sim_message_id value);
const char *sim_subblock_name(enum sim_subblock value);
+const char *sec_message_id_name(enum sec_message_id value);
+
const char *info_isi_cause_name(enum info_isi_cause value);
const char *info_message_id_name(enum info_message_id value);
const char *info_subblock_name(enum info_subblock value);
@@ -78,6 +80,7 @@ void ss_debug(const void *restrict buf, size_t len, void *data);
void mtc_debug(const void *restrict buf, size_t len, void *data);
void sms_debug(const void *restrict buf, size_t len, void *data);
void sim_debug(const void *restrict buf, size_t len, void *data);
+void sec_debug(const void *restrict buf, size_t len, void *data);
void info_debug(const void *restrict buf, size_t len, void *data);
void call_debug(const void *restrict buf, size_t len, void *data);
void net_debug(const void *restrict buf, size_t len, void *data);
diff --git a/drivers/isimodem/sim.c b/drivers/isimodem/sim.c
index d03a07e..1e5ae99 100644
--- a/drivers/isimodem/sim.c
+++ b/drivers/isimodem/sim.c
@@ -45,7 +45,9 @@
struct sim_data {
GIsiClient *client;
- gboolean registered;
+ GIsiClient *sec_client;
+ enum ofono_sim_password_type passwd_state;
+ ofono_bool_t ready;
};
struct file_info {
@@ -326,6 +328,7 @@ static gboolean imsi_resp_cb(GIsiClient *client,
goto out;
error:
+ DBG("IMSI error");
CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);
out:
@@ -342,6 +345,7 @@ static void isi_read_imsi(struct ofono_sim *sim,
SIM_IMSI_REQ_READ_IMSI,
READ_IMSI
};
+ DBG("");
if (!cbd || !sd)
goto error;
@@ -355,50 +359,333 @@ error:
g_free(cbd);
}
-static void isi_sim_register(struct ofono_sim *sim)
+static void isi_query_passwd_state(struct ofono_sim *sim,
+ ofono_sim_passwd_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
+ enum ofono_sim_password_type passwd_state = sd->passwd_state;
- if (!sd->registered) {
- sd->registered = TRUE;
- ofono_sim_register(sim);
- ofono_sim_inserted_notify(sim, TRUE);
+ DBG("passwd_state %u", passwd_state);
+
+ if (passwd_state == OFONO_SIM_PASSWORD_INVALID) {
+ CALLBACK_WITH_FAILURE(cb, -1, data);
+ return;
}
+
+ if (passwd_state == OFONO_SIM_PASSWORD_NONE && !sd->ready) {
+ struct ofono_error error = {
+ .type = OFONO_ERROR_TYPE_CME,
+ .error = 14, /* SIM/UICC not ready */
+ };
+
+ cb(&error, -1, data);
+
+ return;
+ }
+
+ CALLBACK_WITH_SUCCESS(cb, sd->passwd_state, data);
}
-static gboolean read_hplmn_resp_cb(GIsiClient *client,
+static gboolean sec_code_verify_resp(GIsiClient *client,
const void *restrict data, size_t len,
uint16_t object, void *opaque)
{
const unsigned char *msg = data;
- struct ofono_sim *sim = opaque;
+ struct isi_cb_data *cbd = opaque;
+ ofono_sim_lock_unlock_cb_t cb = cbd->cb;
+ struct ofono_sim *sim = cbd->user;
+ struct sim_data *sd = ofono_sim_get_data(sim);
- if (!msg) {
- DBG("ISI client error: %d", g_isi_client_error(client));
- return TRUE;
+ DBG("");
+
+ if (len >= 1 && msg[0] == SEC_CODE_VERIFY_OK_RESP) {
+ sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
+ CALLBACK_WITH_SUCCESS(cb, cbd->data);
+ goto done;
}
- if (len < 3 || msg[0] != SIM_NETWORK_INFO_RESP || msg[1] != READ_HPLMN)
- return FALSE;
+ if (len >= 2 && msg[0] == SEC_CODE_VERIFY_FAIL_RESP &&
+ msg[1] == SEC_CAUSE_CODE_BLOCKED)
+ sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PUK;
- if (msg[2] != SIM_SERV_NOTREADY)
- isi_sim_register(sim);
+ DBG("verify failure %s", !msg ? "(timeout)" : "");
+ CALLBACK_WITH_FAILURE(cb, cbd->data);
+
+done:
+ g_free(cbd);
return TRUE;
}
+static void isi_send_passwd(struct ofono_sim *sim, const char *passwd,
+ ofono_sim_lock_unlock_cb_t cb, void *data)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ struct isi_cb_data *cbd = isi_cb_data_new(sim, cb, data);
+
+ unsigned char msg[2 + SEC_CODE_MAX_LENGTH + 1] = {
+ SEC_CODE_VERIFY_REQ,
+ SEC_CODE_PIN,
+ };
+ int len = 2 + strlen(passwd) + 1;
+
+ DBG("");
-static void isi_read_hplmn(struct ofono_sim *sim)
+ if (!cbd)
+ goto error;
+
+ strcpy((char *)msg + 2, passwd);
+
+ if (g_isi_request_make(sd->sec_client, msg, len, SIM_TIMEOUT,
+ sec_code_verify_resp, cbd))
+ return;
+
+error:
+ g_free(cbd);
+
+ CALLBACK_WITH_FAILURE(cb, data);
+}
+
+static void isi_reset_passwd(struct ofono_sim *sim,
+ const char *puk, const char *passwd,
+ ofono_sim_lock_unlock_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
+ struct isi_cb_data *cbd = isi_cb_data_new(sim, cb, data);
+ enum ofono_sim_password_type passwd_type = OFONO_SIM_PASSWORD_SIM_PIN;
+ unsigned char msg[2 + 2 * (SEC_CODE_MAX_LENGTH + 1)] = {
+ SEC_CODE_VERIFY_REQ,
+ };
- const unsigned char req[] = {
- SIM_NETWORK_INFO_REQ,
- READ_HPLMN, 0
+ DBG("");
+
+ if (!cbd)
+ goto error;
+
+ if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN)
+ msg[1] = SEC_CODE_PIN;
+ else if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN2)
+ msg[1] = SEC_CODE_PIN2;
+ else
+ goto error;
+
+ strcpy((char *)&msg[2], puk);
+ strcpy((char *)&msg[2 + SEC_CODE_MAX_LENGTH + 1], passwd);
+
+ if (g_isi_request_make(sd->sec_client, msg, sizeof(msg), SIM_TIMEOUT,
+ sec_code_verify_resp, cbd))
+ return;
+
+error:
+ g_free(cbd);
+
+ CALLBACK_WITH_FAILURE(cb, data);
+}
+
+
+/* ISI callback: Enable/disable PIN */
+static gboolean pin_enable_resp_cb(GIsiClient *client,
+ const void *restrict data,
+ size_t len, uint16_t object, void *opaque)
+{
+ const unsigned char *msg = data;
+ struct isi_cb_data *cbd = opaque;
+ ofono_sim_lock_unlock_cb_t cb = cbd->cb;
+
+ DBG("");
+
+ if (len < 1 || msg[0] != SEC_CODE_STATE_OK_RESP)
+ CALLBACK_WITH_FAILURE(cb, cbd->data);
+ else
+ CALLBACK_WITH_SUCCESS(cb, cbd->data);
+
+ g_free(cbd);
+
+ return TRUE;
+}
+
+static void isi_lock(struct ofono_sim *sim,
+ enum ofono_sim_password_type passwd_type,
+ int enable, const char *passwd,
+ ofono_sim_lock_unlock_cb_t cb, void *data)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ struct isi_cb_data *cbd = isi_cb_data_new(sim, cb, data);
+ unsigned char msg[3 + SEC_CODE_MAX_LENGTH + 1] = {
+ SEC_CODE_STATE_REQ,
};
- g_isi_request_make(sd->client, req, sizeof(req), SIM_TIMEOUT,
- read_hplmn_resp_cb, sim);
+ if (!cbd)
+ goto error;
+
+ DBG("enable %d pintype %d pass %s", enable, passwd_type, passwd);
+
+ if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN)
+ msg[1] = SEC_CODE_PIN;
+ else if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN2)
+ msg[1] = SEC_CODE_PIN2;
+ else
+ goto error;
+
+ if (enable)
+ msg[2] = SEC_CODE_ENABLE;
+ else
+ msg[2] = SEC_CODE_DISABLE;
+
+ strcpy((char *)&msg[3], passwd);
+
+ if (g_isi_request_make(sd->sec_client, msg, sizeof(msg),
+ SIM_TIMEOUT, pin_enable_resp_cb, cbd))
+ return;
+
+error:
+ g_free(cbd);
+
+ CALLBACK_WITH_FAILURE(cb, data);
+}
+
+
+
+/* ISI callback: PIN state (enabled/disabled) query */
+static gboolean sec_code_change_resp(GIsiClient *client,
+ const void *restrict data, size_t len,
+ uint16_t object, void *opaque)
+{
+ const unsigned char *msg = data;
+ struct isi_cb_data *cbd = opaque;
+ ofono_sim_lock_unlock_cb_t cb = cbd->cb;
+
+ if (len < 1)
+ goto failure;
+
+ if (msg[0] != SEC_CODE_CHANGE_OK_RESP) {
+ if (msg[0] == SEC_CODE_CHANGE_FAIL_RESP && len >= 2)
+ DBG("SEC_CODE_CHANGE_FAIL_RESP(cause=%02x)", msg[1]);
+ goto failure;
+ }
+
+ CALLBACK_WITH_SUCCESS(cb, cbd->data);
+
+ goto done;
+
+failure:
+ CALLBACK_WITH_FAILURE(cb, cbd->data);
+
+done:
+ g_free(cbd);
+
+ return TRUE;
+}
+
+
+static void isi_change_passwd(struct ofono_sim *sim,
+ enum ofono_sim_password_type passwd_type,
+ const char *old, const char *new,
+ ofono_sim_lock_unlock_cb_t cb, void *data)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ struct isi_cb_data *cbd = isi_cb_data_new(sim, cb, data);
+ unsigned char msg[2 + 2 * (SEC_CODE_MAX_LENGTH + 1)] = {
+ SEC_CODE_CHANGE_REQ,
+ };
+
+ DBG("passwd_type %d", passwd_type);
+
+ if (!cbd)
+ goto error;
+
+ if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN)
+ msg[1] = SEC_CODE_PIN;
+ else if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN2)
+ msg[1] = SEC_CODE_PIN2;
+ else
+ goto error;
+
+ strcpy((char *)&msg[2], old);
+ strcpy((char *)&msg[2 + SEC_CODE_MAX_LENGTH + 1], new);
+
+ if (g_isi_request_make(sd->sec_client, msg, sizeof(msg),
+ SIM_TIMEOUT, sec_code_change_resp, cbd))
+ return;
+
+error:
+ g_free(cbd);
+
+ CALLBACK_WITH_FAILURE(cb, data);
+}
+
+
+/* ISI callback: PIN state (enabled/disabled) query */
+static gboolean sec_code_state_resp_cb(GIsiClient *client,
+ const void *restrict data, size_t len,
+ uint16_t object, void *opaque)
+{
+ const unsigned char *msg = data;
+ struct isi_cb_data *cbd = opaque;
+ ofono_sim_locked_cb_t cb = cbd->cb;
+ int locked;
+
+ if (msg == NULL || len < 4)
+ goto failure;
+
+ if (msg[0] != SEC_CODE_STATE_OK_RESP)
+ goto failure;
+
+ DBG("sec state: %02x", msg[1]);
+
+ if (msg[1] == SEC_CODE_ENABLE)
+ locked = 1;
+ else if (msg[1] == SEC_CODE_DISABLE)
+ locked = 0;
+ else
+ goto failure;
+
+ CALLBACK_WITH_SUCCESS(cb, locked, cbd->data);
+
+ goto done;
+
+failure:
+ CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
+
+done:
+ g_free(cbd);
+
+ return TRUE;
+}
+
+static void isi_query_locked(struct ofono_sim *sim,
+ enum ofono_sim_password_type passwd_type,
+ ofono_sim_locked_cb_t cb, void *data)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ struct isi_cb_data *cbd = isi_cb_data_new(sim, cb, data);
+
+ unsigned char msg[] = {
+ SEC_CODE_STATE_REQ,
+ 0,
+ SEC_CODE_STATE_QUERY
+ };
+
+ DBG("");
+
+ if (!cbd)
+ goto error;
+
+ if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN)
+ msg[1] = SEC_CODE_PIN;
+ else if (passwd_type == OFONO_SIM_PASSWORD_SIM_PIN2)
+ msg[1] = SEC_CODE_PIN2;
+ else
+ goto error;
+
+ if (g_isi_request_make(sd->sec_client, msg, sizeof(msg),
+ SIM_TIMEOUT, sec_code_state_resp_cb, cbd))
+ return;
+
+error:
+ g_free(cbd);
+
+ CALLBACK_WITH_FAILURE(cb, -1, data);
}
static void sim_ind_cb(GIsiClient *client,
@@ -409,19 +696,200 @@ static void sim_ind_cb(GIsiClient *client,
struct sim_data *sd = ofono_sim_get_data(sim);
const unsigned char *msg = data;
- if (sd->registered)
+ uint8_t servicetype;
+ uint8_t status;
+ uint8_t state;
+ uint8_t cause;
+
+ DBG("");
+ if (!msg || len < 5 ||
+ (msg[0] != SIM_IND && msg[0] != SIM_SERVER_READY_IND))
return;
+ servicetype = msg[1];
+ status = msg[2];
+ state = msg[3];
+ cause = msg[4];
+
+ if (servicetype == SIM_ST_PIN &&
+ status == SIM_SERV_PIN_VERIFY_REQUIRED) {
+ sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PIN;
+ sd->ready = FALSE;
+ ofono_sim_inserted_notify(sim, TRUE);
+ } else if (status == SIM_SERV_SIM_BLOCKED) {
+ sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PUK;
+ sd->ready = FALSE;
+ ofono_sim_inserted_notify(sim, TRUE);
+ } else if (servicetype == SIM_ST_INFO &&
+ status == SIM_SERV_INIT_OK) {
+ sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
+ ofono_sim_inserted_notify(sim, TRUE);
+ } else if (status == SIM_SERV_SIM_DISCONNECTED) {
+ sd->passwd_state = OFONO_SIM_PASSWORD_INVALID;
+ sd->ready = FALSE;
+ ofono_sim_inserted_notify(sim, FALSE);
+ }
+}
+
+static void sim_server_ready_ind_cb(GIsiClient *client,
+ const void *restrict data, size_t len,
+ uint16_t object, void *opaque)
+{
+ struct ofono_sim *sim = opaque;
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ const unsigned char *msg = data;
+
+ DBG("");
+
+ if (!msg || len < 5 || msg[0] != SIM_SERVER_READY_IND)
+ return;
+
+ sd->ready = TRUE;
+
+ ofono_sim_ready_notify(sim);
+}
+
+static gboolean isi_sim_read_dyn_flags_resp(GIsiClient *client,
+ const void *restrict data, size_t len,
+ uint16_t object, void *opaque)
+{
+ const unsigned char *msg = data;
+ struct ofono_sim *sim = opaque;
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ if (!msg)
+ return TRUE;
+
+ if (len < 2 || msg[0] != SIM_DYNAMIC_FLAGS_RESP)
+ return FALSE;
+
+ if (msg[1] != READ_DYN_FLAGS || msg[2] == SIM_SERV_NOTREADY)
+ return TRUE;
+
+ sd->ready = TRUE;
+
+ ofono_sim_ready_notify(sim);
+
+ return TRUE;
+}
+
+static void isi_sim_read_dyn_flags_req(struct ofono_sim *sim)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ unsigned char req[] = {
+ SIM_DYNAMIC_FLAGS_REQ,
+ READ_DYN_FLAGS,
+ 0
+ };
+
+ g_isi_send(sd->client, req, sizeof(req), SIM_TIMEOUT,
+ isi_sim_read_dyn_flags_resp, sim, NULL);
+}
+
+static gboolean sec_state_resp_cb(GIsiClient *client,
+ const void *restrict data, size_t len,
+ uint16_t object, void *opaque)
+{
+ const unsigned char *msg = data;
+ struct ofono_sim *sim = opaque;
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ ofono_bool_t inserted = FALSE;
+
+ DBG("");
+
+ if (!msg) {
+ DBG("ISI client error: %d", g_isi_client_error(client));
+ return TRUE;
+ }
+ if (len < 2 || msg[0] != SEC_STATE_RESP)
+ return FALSE;
+
+ if (!sd)
+ return TRUE;
+
switch (msg[1]) {
- case SIM_ST_PIN:
- isi_sim_register(sim);
+ case SEC_STARTUP_OK:
+ DBG("SEC_STARTUP_OK");
+ sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
+ inserted = TRUE;
+ /* Check if SIM server is already ready */
+ isi_sim_read_dyn_flags_req(sim);
+ break;
+ case SEC_CAUSE_PIN_REQUIRED:
+ DBG("SEC_CAUSE_PIN_REQUIRED");
+ sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PIN;
+ inserted = TRUE;
+ break;
+ case SEC_CAUSE_PUK_REQUIRED:
+ DBG("SEC_CAUSE_PUK_REQUIRED");
+ sd->passwd_state = OFONO_SIM_PASSWORD_SIM_PUK;
+ inserted = TRUE;
break;
- case SIM_ST_INFO:
- isi_read_hplmn(sim);
+ case SEC_CAUSE_NO_SIM:
+ DBG("SEC_CAUSE_NO_SIM");
+ break;
+ case SEC_CAUSE_INVALID_SIM:
+ DBG("SEC_CAUSE_INVALID_SIM");
+ break;
+ case SEC_CAUSE_SIM_REJECTED:
+ DBG("SEC_CAUSE_SIM_REJECTED");
+ break;
+ default:
break;
}
+
+ ofono_sim_inserted_notify(sim, inserted);
+
+ return TRUE;
+}
+
+static void isi_sec_state_req(struct ofono_sim *sim)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ unsigned char req[] = {
+ SEC_STATE_REQ,
+ 0,
+ 0
+ };
+
+ g_isi_request_make(sd->sec_client, req, sizeof(req), SIM_TIMEOUT,
+ sec_state_resp_cb, sim);
+}
+
+static gboolean sim_status_resp_cb(GIsiClient *client,
+ const void *restrict data, size_t len,
+ uint16_t object, void *opaque)
+{
+ const unsigned char *msg = data;
+ struct ofono_sim *sim = opaque;
+
+ if (!msg || len < 3)
+ return TRUE;
+
+ if (msg[0] == SIM_STATUS_RESP && msg[1] == SIM_ST_CARD_STATUS &&
+ msg[2] != SIM_SERV_SIM_DISCONNECTED)
+ /* We probably have a SIM. Now get PIN/PUK status */
+ isi_sec_state_req(sim); /* Try Sec-server first */
+
+ return TRUE;
}
+static void isi_sim_status_req(struct ofono_sim *sim)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ const unsigned char req[] = {
+ SIM_STATUS_REQ,
+ SIM_ST_CARD_STATUS
+ };
+
+ g_isi_request_make(sd->client, req, sizeof(req), SIM_TIMEOUT,
+ sim_status_resp_cb, sim);
+}
+
+
static void sim_reachable_cb(GIsiClient *client, gboolean alive,
uint16_t object, void *opaque)
{
@@ -439,9 +907,13 @@ static void sim_reachable_cb(GIsiClient *client, gboolean alive,
g_isi_version_minor(client));
g_isi_subscribe(client, SIM_IND, sim_ind_cb, opaque);
+ g_isi_subscribe(client, SIM_SERVER_READY_IND,
+ sim_server_ready_ind_cb, opaque);
- /* Check if SIM is ready. */
- isi_read_hplmn(sim);
+ ofono_sim_register(sim);
+
+ /* Check if we have a SIM */
+ isi_sim_status_req(sim);
}
static int isi_sim_probe(struct ofono_sim *sim, unsigned int vendor,
@@ -449,23 +921,41 @@ static int isi_sim_probe(struct ofono_sim *sim, unsigned int
vendor,
{
GIsiModem *idx = user;
struct sim_data *sd = g_try_new0(struct sim_data, 1);
+ GIsiClient *client = NULL;
+ GIsiClient *sec_client = NULL;
const char *debug = getenv("OFONO_ISI_DEBUG");
if (!sd)
- return -ENOMEM;
+ goto error;
- sd->client = g_isi_client_create(idx, PN_SIM);
- if (!sd->client)
- return -ENOMEM;
+ client = g_isi_client_create(idx, PN_SIM);
+ if (!client)
+ goto error;
+
+ sec_client = g_isi_client_create(idx, PN_SECURITY);
+ if (!sec_client)
+ goto error;
+
+ sd->client = client;
+ sd->sec_client = sec_client;
+ sd->passwd_state = OFONO_SIM_PASSWORD_INVALID;
ofono_sim_set_data(sim, sd);
- if (debug && (strcmp(debug, "all") == 0 || strcmp(debug,
"sim") == 0))
+ if (debug && (!strcmp(debug, "all") || !strcmp(debug,
"sim"))) {
g_isi_client_set_debug(sd->client, sim_debug, NULL);
+ g_isi_client_set_debug(sd->sec_client, sec_debug, NULL);
+ }
g_isi_verify(sd->client, sim_reachable_cb, sim);
return 0;
+
+error:
+ g_isi_client_destroy(client);
+ g_isi_client_destroy(sec_client);
+
+ return -ENOMEM;
}
static void isi_sim_remove(struct ofono_sim *sim)
@@ -477,6 +967,7 @@ static void isi_sim_remove(struct ofono_sim *sim)
ofono_sim_set_data(sim, NULL);
g_isi_client_destroy(data->client);
+ g_isi_client_destroy(data->sec_client);
g_free(data);
}
@@ -492,6 +983,12 @@ static struct ofono_sim_driver driver = {
.write_file_linear = isi_write_file_linear,
.write_file_cyclic = isi_write_file_cyclic,
.read_imsi = isi_read_imsi,
+ .query_passwd_state = isi_query_passwd_state,
+ .send_passwd = isi_send_passwd,
+ .reset_passwd = isi_reset_passwd,
+ .lock = isi_lock,
+ .change_passwd = isi_change_passwd,
+ .query_locked = isi_query_locked,
};
void isi_sim_init()
diff --git a/drivers/isimodem/sim.h b/drivers/isimodem/sim.h
index f1d9f47..f416666 100644
--- a/drivers/isimodem/sim.h
+++ b/drivers/isimodem/sim.h
@@ -27,9 +27,12 @@ extern "C" {
#endif
#define PN_SIM 0x09
+#define PN_SECURITY 0x08
#define SIM_TIMEOUT 5
#define SIM_MAX_IMSI_LENGTH 15
+#define SEC_CODE_MAX_LENGTH 0x0A
+
enum sim_isi_cause {
SIM_SERV_NOT_AVAIL = 0x00,
SIM_SERV_OK = 0x01,
@@ -131,29 +134,74 @@ enum sim_message_id {
SIM_IMSI_RESP_READ_IMSI = 0x1E,
SIM_SERV_PROV_NAME_REQ = 0x21,
SIM_SERV_PROV_NAME_RESP = 0x22,
+ SIM_DYNAMIC_FLAGS_REQ = 0x29,
+ SIM_DYNAMIC_FLAGS_RESP = 0x2A,
SIM_READ_FIELD_REQ = 0xBA,
SIM_READ_FIELD_RESP = 0xBB,
SIM_SMS_REQ = 0xBC,
SIM_SMS_RESP = 0xBD,
+ SIM_STATUS_REQ = 0xC0,
+ SIM_STATUS_RESP = 0xC1,
SIM_PB_REQ_SIM_PB_READ = 0xDC,
SIM_PB_RESP_SIM_PB_READ = 0xDD,
+ SIM_SERVER_READY_IND = 0xED,
SIM_IND = 0xEF,
SIM_COMMON_MESSAGE = 0xF0
};
enum sim_service_type {
+ SIM_ST_CARD_STATUS = 0x00,
SIM_ST_PIN = 0x01,
SIM_ST_ALL_SERVICES = 0x05,
SIM_ST_INFO = 0x0D,
- SIM_ST_READ_SERV_PROV_NAME = 0x2C,
SIM_PB_READ = 0x0F,
+ SIM_ST_READ_SERV_PROV_NAME = 0x2C,
READ_IMSI = 0x2D,
READ_HPLMN = 0x2F,
+ READ_DYN_FLAGS = 0x35,
READ_PARAMETER = 0x52,
UPDATE_PARAMETER = 0x53,
ICC = 0x66,
};
+enum sec_message_id {
+ SEC_CODE_STATE_REQ = 0x01,
+ SEC_CODE_STATE_OK_RESP = 0x02,
+ SEC_CODE_STATE_FAIL_RESP = 0x03,
+ SEC_CODE_CHANGE_REQ = 0x04,
+ SEC_CODE_CHANGE_OK_RESP = 0x05,
+ SEC_CODE_CHANGE_FAIL_RESP = 0x06,
+ SEC_CODE_VERIFY_REQ = 0x07,
+ SEC_CODE_VERIFY_OK_RESP = 0x08,
+ SEC_CODE_VERIFY_FAIL_RESP = 0x09,
+ SEC_STATE_REQ = 0x11,
+ SEC_STATE_RESP = 0x12,
+};
+
+enum sec_code_id_info {
+ SEC_CODE_PIN = 0x02,
+ SEC_CODE_PUK = 0x03,
+ SEC_CODE_PIN2 = 0x04,
+ SEC_CODE_PUK2 = 0x05,
+};
+
+enum sec_code_state_info {
+ SEC_CODE_DISABLE = 0x00,
+ SEC_CODE_ENABLE = 0x01,
+ SEC_CODE_STATE_QUERY = 0x04,
+};
+
+enum sec_state_cause_info {
+ SEC_CAUSE_PIN_REQUIRED = 0x02,
+ SEC_CAUSE_PUK_REQUIRED = 0x03,
+ SEC_STARTUP_OK = 0x05,
+ SEC_STARTUP_ONGOING = 0x07,
+ SEC_CAUSE_CODE_BLOCKED = 0x08,
+ SEC_CAUSE_NO_SIM = 0x16,
+ SEC_CAUSE_SIM_REJECTED = 0x1A,
+ SEC_CAUSE_INVALID_SIM = 0x1E,
+};
+
#ifdef __cplusplus
};
#endif
--
1.7.1
7:27 a.m.
New subject: [sim-ready-v2 PATCH 3/3] atmodem/sim: use ofono_sim_ready_notify
From: Pekka Pessi <Pekka.Pessi(a)nokia.com>
Retry with ofono_sim_ready_notify after a timeout if CPIN? returns CME
error 14 (SIM busy).
If there is a ready notification registered but no such notification has
been received, return the CME error 14. If ready notification has been
received, return normally.
---
drivers/atmodem/sim.c | 182 +++++++++++++++++++++++++++++++++++++++----------
src/simutil.h | 2 +
2 files changed, 147 insertions(+), 37 deletions(-)
diff --git a/drivers/atmodem/sim.c b/drivers/atmodem/sim.c
index 9cfdc65..3ea8f87 100644
--- a/drivers/atmodem/sim.c
+++ b/drivers/atmodem/sim.c
@@ -44,10 +44,17 @@
#define EF_STATUS_INVALIDATED 0
#define EF_STATUS_VALID 1
+/* Timeout in milliseconds when there is ready notification */
+#define READY_TIMEOUT 5000
+/* Timeout in milliseconds without ready notification */
+#define BUSY_TIMEOUT 500
+
struct sim_data {
GAtChat *chat;
unsigned int vendor;
+ ofono_bool_t ready;
guint ready_id;
+ guint ready_source;
};
static const char *crsm_prefix[] = { "+CRSM:", NULL };
@@ -456,10 +463,65 @@ static struct {
{ OFONO_SIM_PASSWORD_PHCORP_PUK, "PH-CORP PUK" },
};
+static void ready_unregister_and_notify(struct ofono_sim *sim)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ DBG("enter");
+
+ if (sd->ready_source > 0)
+ g_source_remove(sd->ready_source);
+ sd->ready_source = 0;
+
+ if (sd->ready_id > 0)
+ g_at_chat_unregister(sd->chat, sd->ready_id);
+ sd->ready_id = 0;
+
+ ofono_sim_ready_notify(sim);
+}
+
+static gboolean ready_timeout(gpointer user_data)
+{
+ struct ofono_sim *sim = user_data;
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ DBG("enter");
+
+ sd->ready_source = 0;
+ ready_unregister_and_notify(sim);
+
+ return FALSE;
+}
+
+static void at_check_sim_busy(struct ofono_sim *sim,
+ struct ofono_error *error)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+
+ if (error->type != OFONO_ERROR_TYPE_CME)
+ return;
+ if (error->error != 14)
+ return;
+
+ if (sd->ready_source > 0)
+ return;
+
+ sd->ready_source = g_timeout_add(BUSY_TIMEOUT, ready_timeout, sim);
+}
+
+#define CALLBACK_WITH_SIM_BUSY(f, args...) \
+ do { \
+ struct ofono_error e; \
+ e.type = OFONO_ERROR_TYPE_CME; \
+ e.error = 14; \
+ f(&e, ##args); \
+ } while (0)
+
static void at_cpin_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
- struct sim_data *sd = ofono_sim_get_data(cbd->user);
+ struct ofono_sim *sim = cbd->user;
+ struct sim_data *sd = ofono_sim_get_data(sim);
GAtResultIter iter;
ofono_sim_passwd_cb_t cb = cbd->cb;
struct ofono_error error;
@@ -475,6 +537,7 @@ static void at_cpin_cb(gboolean ok, GAtResult *result, gpointer
user_data)
decode_at_error(&error, final);
if (!ok) {
+ at_check_sim_busy(sim, &error);
cb(&error, -1, cbd->data);
return;
}
@@ -506,8 +569,18 @@ static void at_cpin_cb(gboolean ok, GAtResult *result, gpointer
user_data)
return;
}
- DBG("crsm_pin_cb: %s", pin_required);
+ if (!sd->ready && sd->ready_id > 0 && sd->ready_source >
0) {
+ CALLBACK_WITH_SIM_BUSY(cb, -1, cbd->data);
+ return;
+ }
+ switch (pin_type) {
+ case OFONO_SIM_PASSWORD_SIM_PIN:
+ case OFONO_SIM_PASSWORD_SIM_PUK:
+ sd->ready = FALSE;
+ }
+
+ DBG("crsm_pin_cb: %s", pin_required);
cb(&error, pin_type, cbd->data);
}
@@ -534,10 +607,8 @@ error:
static void at_xsim_notify(GAtResult *result, gpointer user_data)
{
- struct cb_data *cbd = user_data;
- struct sim_data *sd = cbd->user;
- ofono_sim_lock_unlock_cb_t cb = cbd->cb;
- struct ofono_error error = { .type = OFONO_ERROR_TYPE_NO_ERROR };
+ struct ofono_sim *sim = user_data;
+ struct sim_data *sd = ofono_sim_get_data(sim);
GAtResultIter iter;
int state;
@@ -557,37 +628,29 @@ static void at_xsim_notify(GAtResult *result, gpointer user_data)
return;
}
- cb(&error, cbd->data);
+ sd->ready = TRUE;
- g_at_chat_unregister(sd->chat, sd->ready_id);
- sd->ready_id = 0;
+ if (sd->ready_source > 0)
+ ready_unregister_and_notify(sim);
}
static void at_epev_notify(GAtResult *result, gpointer user_data)
{
- struct cb_data *cbd = user_data;
- struct sim_data *sd = cbd->user;
- ofono_sim_lock_unlock_cb_t cb = cbd->cb;
- struct ofono_error error = { .type = OFONO_ERROR_TYPE_NO_ERROR };
+ struct ofono_sim *sim = user_data;
+ struct sim_data *sd = ofono_sim_get_data(sim);
- cb(&error, cbd->data);
+ sd->ready = TRUE;
- g_at_chat_unregister(sd->chat, sd->ready_id);
- sd->ready_id = 0;
+ if (sd->ready_source > 0)
+ ready_unregister_and_notify(sim);
}
-static void at_pin_send_cb(gboolean ok, GAtResult *result,
- gpointer user_data)
+static void at_register_ready(struct ofono_sim *sim)
{
- struct cb_data *cbd = user_data;
- struct sim_data *sd = cbd->user;
- ofono_sim_lock_unlock_cb_t cb = cbd->cb;
- struct ofono_error error;
-
- decode_at_error(&error, g_at_result_final_response(result));
+ struct sim_data *sd = ofono_sim_get_data(sim);
- if (!ok)
- goto done;
+ if (sd->ready_id > 0)
+ return;
switch (sd->vendor) {
case OFONO_VENDOR_IFX:
@@ -598,24 +661,64 @@ static void at_pin_send_cb(gboolean ok, GAtResult *result,
*/
sd->ready_id = g_at_chat_register(sd->chat, "+XSIM",
at_xsim_notify,
- FALSE, cbd, g_free);
- return;
+ FALSE, sim, NULL);
+ break;
+
case OFONO_VENDOR_MBM:
/*
* On the MBM modem, AT+CPIN? keeps returning SIM PIN
* for a moment after successful AT+CPIN="..", but then
- * sends *EPEV when that changes.
+ * sends *EPEV when that changes. Sometimes.
*/
sd->ready_id = g_at_chat_register(sd->chat, "*EPEV",
at_epev_notify,
- FALSE, cbd, g_free);
+ FALSE, sim, NULL);
+ break;
+ }
+}
+
+static void at_wait_for_ready(struct ofono_sim *sim)
+{
+ struct sim_data *sd = ofono_sim_get_data(sim);
+ guint timeout;
+
+ if (sd->ready)
+ return;
+
+ at_register_ready(sim);
+
+ switch (sd->vendor) {
+ case OFONO_VENDOR_IFX:
+ timeout = READY_TIMEOUT;
+ break;
+
+ case OFONO_VENDOR_MBM:
+ timeout = READY_TIMEOUT;
+ break;
+
+ default:
return;
}
-done:
- cb(&error, cbd->data);
+ if (sd->ready_source)
+ g_source_remove(sd->ready_source);
+ sd->ready_source = g_timeout_add(timeout, ready_timeout, sim);
+}
- g_free(cbd);
+static void at_pin_send_cb(gboolean ok, GAtResult *result,
+ gpointer user_data)
+{
+ struct cb_data *cbd = user_data;
+ struct ofono_sim *sim = cbd->user;
+ ofono_sim_lock_unlock_cb_t cb = cbd->cb;
+ struct ofono_error error;
+
+ decode_at_error(&error, g_at_result_final_response(result));
+
+ if (ok)
+ at_wait_for_ready(sim);
+
+ cb(&error, cbd->data);
}
static void at_pin_send(struct ofono_sim *sim, const char *passwd,
@@ -629,12 +732,14 @@ static void at_pin_send(struct ofono_sim *sim, const char *passwd,
if (!cbd)
goto error;
- cbd->user = sd;
+ cbd->user = sim;
+
+ sd->ready = FALSE;
snprintf(buf, sizeof(buf), "AT+CPIN=\"%s\"", passwd);
ret = g_at_chat_send(sd->chat, buf, none_prefix,
- at_pin_send_cb, cbd, NULL);
+ at_pin_send_cb, cbd, g_free);
memset(buf, 0, sizeof(buf));
@@ -659,12 +764,12 @@ static void at_pin_send_puk(struct ofono_sim *sim, const char *puk,
if (!cbd)
goto error;
- cbd->user = sd;
+ cbd->user = sim;
snprintf(buf, sizeof(buf), "AT+CPIN=\"%s\",\"%s\"", puk,
passwd);
ret = g_at_chat_send(sd->chat, buf, none_prefix,
- at_pin_send_cb, cbd, NULL);
+ at_pin_send_cb, cbd, g_free);
memset(buf, 0, sizeof(buf));
@@ -858,6 +963,9 @@ static int at_sim_probe(struct ofono_sim *sim, unsigned int vendor,
}
ofono_sim_set_data(sim, sd);
+
+ at_register_ready(sim);
+
g_idle_add(at_sim_register, sim);
return 0;
diff --git a/src/simutil.h b/src/simutil.h
index 5b56099..7b07f16 100644
--- a/src/simutil.h
+++ b/src/simutil.h
@@ -24,6 +24,7 @@ enum sim_fileid {
SIM_EF_ICCID_FILEID = 0x2fe2,
SIM_EFIMG_FILEID = 0x4F20,
SIM_EFLI_FILEID = 0x6f05,
+ SIM_EFIMSI_FILEID = 0x6f07,
SIM_EF_CPHS_MWIS_FILEID = 0x6f11,
SIM_EF_CPHS_INFORMATION_FILEID = 0x6f16,
SIM_EF_CPHS_MBDN_FILEID = 0x6f17,
@@ -45,6 +46,7 @@ enum sim_fileid {
SIM_EFSPDI_FILEID = 0x6fcd,
SIM_EFECC_FILEID = 0x6fb7,
SIM_EFCBMIR_FILEID = 0x6f50,
+ SIM_EFNIA_FILEID = 0x6f51,
SIM_EFCBMI_FILEID = 0x6f45,
SIM_EFCBMID_FILEID = 0x6f48,
};
--
1.7.1
4332
days inactive
4332
days old
3 comments
1 participants
participants (1)
-
Pekka.Pessi＠nokia.com