static int option_parse_tech(GAtResult *result)
{
GAtResultIter iter;
int s, octi, ouwcti;
int tech;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "_OCTI:"))
return -1;
if (!g_at_result_iter_next_number(&iter, &s))
return -1;
if (!g_at_result_iter_next_number(&iter, &octi))
return -1;
if (!g_at_result_iter_next(&iter, "_OUWCTI:"))
return -1;
if (!g_at_result_iter_next_number(&iter, &s))
return -1;
if (!g_at_result_iter_next_number(&iter, &ouwcti))
return -1;
switch (octi) {
case 1: /* GSM */
tech = ACCESS_TECHNOLOGY_GSM;
break;
case 2: /* GPRS */
tech = ACCESS_TECHNOLOGY_GSM;
break;
case 3: /* EDGE */
tech = ACCESS_TECHNOLOGY_GSM_EGPRS;
break;
default:
tech = -1;
break;
}
switch (ouwcti) {
case 1: /* UMTS */
tech = ACCESS_TECHNOLOGY_UTRAN;
break;
case 2: /* HSDPA */
tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA;
break;
case 3: /* HSUPA */
tech = ACCESS_TECHNOLOGY_UTRAN_HSUPA;
break;
case 4: /* HSPA */
tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA_HSUPA;
break;
}
DBG("octi %d ouwcti %d tech %d", octi, ouwcti, tech);
return tech;
}
static void at_discover_apps_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct cb_data *cbd = user_data;
GAtResultIter iter;
ofono_sim_list_apps_cb_t cb = cbd->cb;
struct ofono_error error;
const unsigned char *dataobj;
gint linelen;
unsigned char *buffer;
int len;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, NULL, 0, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
len = 0;
while (g_at_result_iter_next(&iter, "+CUAD:")) {
if (!g_at_result_iter_next_hexstring(&iter, NULL, &linelen))
goto error;
len += linelen;
}
g_at_result_iter_init(&iter, result);
buffer = g_malloc(len);
len = 0;
while (g_at_result_iter_next(&iter, "+CUAD:")) {
g_at_result_iter_next_hexstring(&iter, &dataobj, &linelen);
memcpy(buffer + len, dataobj, linelen);
len += linelen;
}
cb(&error, buffer, len, cbd->data);
g_free(buffer);
return;
error:
CALLBACK_WITH_FAILURE(cb, NULL, 0, cbd->data);
}
static void csq_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_netreg_strength_cb_t cb = cbd->cb;
int strength;
GAtResultIter iter;
struct ofono_error error;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CSQ:")) {
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
return;
}
g_at_result_iter_next_number(&iter, &strength);
DBG("csq_cb: %d", strength);
if (strength == 99)
strength = -1;
else
strength = (strength * 100) / 31;
cb(&error, strength, cbd->data);
}
static void ifx_ctzdst_notify(GAtResult *result, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
int dst;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CTZDST:"))
return;
if (!g_at_result_iter_next_number(&iter, &dst))
return;
DBG("dst %d", dst);
nd->time.dst = dst;
if (nd->nitz_timeout > 0) {
g_source_remove(nd->nitz_timeout);
nd->nitz_timeout = 0;
}
ofono_netreg_time_notify(netreg, &nd->time);
}
static void ciev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *nd = ofono_netreg_get_data(netreg);
int strength, ind;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CIEV:"))
return;
if (!g_at_result_iter_next_number(&iter, &ind))
return;
if (ind != nd->signal_index)
return;
if (!g_at_result_iter_next_number(&iter, &strength))
return;
if (strength == nd->signal_invalid)
strength = -1;
else
strength = (strength * 100) / (nd->signal_max - nd->signal_min);
ofono_netreg_strength_notify(netreg, strength);
}
static void rat_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_radio_settings_rat_mode_query_cb_t cb = cbd->cb;
enum ofono_radio_access_mode mode;
struct ofono_error error;
GAtResultIter iter;
int value;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CFUN:"))
goto err;
if (!g_at_result_iter_next_number(&iter, &value))
goto err;
if (!ste_mode_to_ofono_mode(value, &mode))
goto err;
CALLBACK_WITH_SUCCESS(cb, mode, cbd->data);
return;
err:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void cgev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs_context *gc = user_data;
struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
GAtResultIter iter;
const char *event;
gint cid;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGEV:"))
return;
if (!g_at_result_iter_next_unquoted_string(&iter, &event))
return;
if (g_str_has_prefix(event, "NW PDN DEACT"))
sscanf(event, "%*s %*s %*s %u", &cid);
else if (g_str_has_prefix(event, "NW DEACT"))
sscanf(event, "%*s %*s %u", &cid);
else
return;
DBG("cid %d", cid);
if ((unsigned int) cid != gcd->active_context)
return;
ofono_gprs_context_deactivated(gc, gcd->active_context);
gcd->active_context = 0;
}
static void bcs_notify(GAtResult *result, gpointer user_data)
{
struct hfp *hfp = user_data;
struct hfp_slc_info *info = &hfp->info;
GAtResultIter iter;
char str[32];
int value;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+BCS:"))
return;
if (!g_at_result_iter_next_number(&iter, &value))
return;
if (ofono_handsfree_card_set_codec(hfp->card, value) == FALSE) {
/* Unsupported codec, re-send our codecs */
if (ofono_handsfree_audio_has_wideband())
sprintf(str, "AT+BAC=%d,%d", HFP_CODEC_CVSD,
HFP_CODEC_MSBC);
else
sprintf(str, "AT+BAC=%d", HFP_CODEC_CVSD);
goto done;
}
/* Confirm the codec */
sprintf(str, "AT+BCS=%d", value);
done:
g_at_chat_send(info->chat, str, none_prefix, NULL, NULL, NULL);
}
static void ublox_ureg_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
GAtResultIter iter;
gint state, bearer;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+UREG:"))
return;
if (!g_at_result_iter_next_number(&iter, &state))
return;
switch (state) {
case 4:
bearer = 5;
break;
case 5:
bearer = 4;
break;
case 8:
bearer = 1;
break;
case 9:
bearer = 2;
break;
default:
bearer = state;
}
ofono_gprs_bearer_notify(gprs, bearer);
}
static void cgev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
struct gprs_data *gd = ofono_gprs_get_data(gprs);
GAtResultIter iter;
const char *event;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGEV:"))
return;
if (!g_at_result_iter_next_unquoted_string(&iter, &event))
return;
if (g_str_equal(event, "NW DETACH") ||
g_str_equal(event, "ME DETACH")) {
if (gd->vendor == OFONO_VENDOR_TELIT &&
gd->telit_try_reattach)
return;
gd->attached = FALSE;
ofono_gprs_detached_notify(gprs);
return;
} else if (g_str_has_prefix(event, "ME PDN ACT")) {
sscanf(event, "%*s %*s %*s %u", &gd->last_auto_context_id);
g_at_chat_send(gd->chat, "AT+CGDCONT?", cgdcont_prefix,
at_cgdcont_read_cb, gprs, NULL);
}
}
static void at_cgsms_query_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_sms_bearer_query_cb_t cb = cbd->cb;
struct ofono_error error;
GAtResultIter iter;
int bearer;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGSMS:"))
goto err;
g_at_result_iter_next_number(&iter, &bearer);
cb(&error, bearer, cbd->data);
return;
err:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void cops_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct netreg_data *nd = ofono_netreg_get_data(cbd->user);
ofono_netreg_operator_cb_t cb = cbd->cb;
struct ofono_network_operator op;
GAtResultIter iter;
int format, tech;
const char *name;
struct ofono_error error;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok)
goto error;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+COPS:"))
goto error;
g_at_result_iter_skip_next(&iter);
ok = g_at_result_iter_next_number(&iter, &format);
if (ok == FALSE || format != 0)
goto error;
if (g_at_result_iter_next_string(&iter, &name) == FALSE)
goto error;
/* Default to GSM */
if (g_at_result_iter_next_number(&iter, &tech) == FALSE)
tech = ACCESS_TECHNOLOGY_GSM;
strncpy(op.name, name, OFONO_MAX_OPERATOR_NAME_LENGTH);
op.name[OFONO_MAX_OPERATOR_NAME_LENGTH] = '\0';
strncpy(op.mcc, nd->mcc, OFONO_MAX_MCC_LENGTH);
op.mcc[OFONO_MAX_MCC_LENGTH] = '\0';
strncpy(op.mnc, nd->mnc, OFONO_MAX_MNC_LENGTH);
op.mnc[OFONO_MAX_MNC_LENGTH] = '\0';
/* Set to current */
op.status = 2;
op.tech = tech;
DBG("cops_cb: %s, %s %s %d", name, nd->mcc, nd->mnc, tech);
cb(&error, &op, cbd->data);
g_free(cbd);
return;
error:
cb(&error, NULL, cbd->data);
g_free(cbd);
}
static void ctm_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct ofono_error error;
GAtResultIter iter;
ofono_ctm_query_cb_t cb = cbd->cb;
int value;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "+PTTY:") == FALSE)
goto error;
if (g_at_result_iter_next_number(&iter, &value) == FALSE)
goto error;
cb(&error, value, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void cbc_notify(GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct phonesim_data *data = ofono_modem_get_data(modem);
GAtResultIter iter;
int status;
int level;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CBC:"))
return;
if (!g_at_result_iter_next_number(&iter, &status))
return;
if (!g_at_result_iter_next_number(&iter, &level))
return;
data->batt_level = level;
__ofono_modem_foreach_registered_atom(modem,
OFONO_ATOM_TYPE_EMULATOR_HFP,
emulator_battery_cb,
GUINT_TO_POINTER(level));
}
static void xctms_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_ctm_query_cb_t cb = cbd->cb;
struct ofono_error error;
GAtResultIter iter;
int value;
ofono_bool_t enable;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, "+XCTMS:") == FALSE)
goto error;
if (g_at_result_iter_next_number(&iter, &value) == FALSE)
goto error;
/* FULL TTY mode status only sent to oFono */
enable = (value == 1) ? TRUE : FALSE;
cb(&error, enable, cbd->data);
return;
error:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void ste_cgact_read_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_gprs_context *gc = user_data;
struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
gint cid, state;
GAtResultIter iter;
if (!ok)
return;
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, "+CGACT:")) {
if (!g_at_result_iter_next_number(&iter, &cid))
continue;
if ((unsigned int) cid != gcd->active_context)
continue;
if (!g_at_result_iter_next_number(&iter, &state))
continue;
if (state == 1)
continue;
ofono_gprs_context_deactivated(gc, gcd->active_context);
gcd->active_context = 0;
break;
}
}
static void cind_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct slc_establish_data *sed = user_data;
struct hfp_slc_info *info = sed->info;
GAtResultIter iter;
const char *str;
int index;
int min, max;
if (!ok)
goto error;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CIND:"))
goto error;
index = 1;
while (g_at_result_iter_open_list(&iter)) {
if (!g_at_result_iter_next_string(&iter, &str))
goto error;
if (!g_at_result_iter_open_list(&iter))
goto error;
while (g_at_result_iter_next_range(&iter, &min, &max))
;
if (!g_at_result_iter_close_list(&iter))
goto error;
if (!g_at_result_iter_close_list(&iter))
goto error;
if (g_str_equal("service", str) == TRUE)
info->cind_pos[HFP_INDICATOR_SERVICE] = index;
else if (g_str_equal("call", str) == TRUE)
info->cind_pos[HFP_INDICATOR_CALL] = index;
else if (g_str_equal("callsetup", str) == TRUE)
info->cind_pos[HFP_INDICATOR_CALLSETUP] = index;
else if (g_str_equal("callheld", str) == TRUE)
info->cind_pos[HFP_INDICATOR_CALLHELD] = index;
else if (g_str_equal("signal", str) == TRUE)
info->cind_pos[HFP_INDICATOR_SIGNAL] = index;
else if (g_str_equal("roam", str) == TRUE)
info->cind_pos[HFP_INDICATOR_ROAM] = index;
else if (g_str_equal("battchg", str) == TRUE)
info->cind_pos[HFP_INDICATOR_BATTCHG] = index;
index += 1;
}
slc_establish_data_ref(sed);
g_at_chat_send(info->chat, "AT+CIND?", cind_prefix,
cind_status_cb, sed, slc_establish_data_unref);
return;
error:
slc_failed(sed);
}
static void cgev_notify(GAtResult *result, gpointer user_data)
{
struct ofono_gprs_context *gc = user_data;
struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);
const char *event;
int cid;
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGEV:"))
return;
if (!g_at_result_iter_next_unquoted_string(&iter, &event))
return;
if (g_str_has_prefix(event, "NW DEACT") == FALSE)
return;
if (!g_at_result_iter_skip_next(&iter))
return;
if (!g_at_result_iter_next_number(&iter, &cid))
return;
DBG("cid %d", cid);
if ((unsigned int) cid != gcd->active_context)
return;
if (gcd->state != STATE_IDLE && gcd->ppp)
g_at_ppp_shutdown(gcd->ppp);
}
static void at_csms_query_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_sms *sms = user_data;
struct sms_data *data = ofono_sms_get_data(sms);
gboolean cnma_supported = FALSE;
GAtResultIter iter;
int status_min, status_max;
char buf[128];
if (!ok)
return at_sms_not_supported(sms);
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CSMS:"))
goto out;
if (!g_at_result_iter_open_list(&iter))
goto out;
while (g_at_result_iter_next_range(&iter, &status_min, &status_max))
if (status_min <= 1 && 1 <= status_max)
cnma_supported = TRUE;
DBG("CSMS query parsed successfully");
out:
snprintf(buf, sizeof(buf), "AT+CSMS=%d", cnma_supported ? 1 : 0);
g_at_chat_send(data->chat, buf, csms_prefix,
at_csms_set_cb, sms, NULL);
}
static void at_cmgs_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
GAtResultIter iter;
ofono_sms_submit_cb_t cb = cbd->cb;
struct ofono_error error;
int mr;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CMGS:"))
goto err;
if (!g_at_result_iter_next_number(&iter, &mr))
goto err;
DBG("Got MR: %d", mr);
cb(&error, mr, cbd->data);
return;
err:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
}
static void at_cmgf_query_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_sms *sms = user_data;
struct sms_data *data = ofono_sms_get_data(sms);
gboolean supported = FALSE;
if (ok) {
GAtResultIter iter;
int mode;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CMGF:"))
goto out;
if (!g_at_result_iter_open_list(&iter))
goto out;
/* Look for mode 0 (PDU mode) */
while (g_at_result_iter_next_number(&iter, &mode))
if (mode == 0)
supported = TRUE;
}
out:
if (!supported)
return at_sms_not_supported(sms);
g_at_chat_send(data->chat, "AT+CPMS=?", cpms_prefix,
at_cpms_query_cb, sms, NULL);
}
static void xsimstate_query(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
GAtResultIter iter;
int mode;
int state;
DBG("");
if (!ok)
return;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+XSIMSTATE:"))
return;
if (!g_at_result_iter_next_number(&iter, &mode))
return;
if (!g_at_result_iter_next_number(&iter, &state))
return;
ifx_set_sim_state(data, state);
}
static void ccfc_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_call_forwarding_query_cb_t cb = cbd->cb;
struct ofono_error error;
GAtResultIter iter;
int num = 0;
struct ofono_call_forwarding_condition *list = NULL;
int i;
int maxlen;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok)
goto out;
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, "+CCFC:"))
num += 1;
/* Specification is really unclear about this
* generate status=0 for all classes just in case
*/
if (num == 0) {
list = g_new0(struct ofono_call_forwarding_condition, 1);
num = 1;
list->status = 0;
list->cls = GPOINTER_TO_INT(cbd->user);
goto out;
}
static void at_cgdcont_test_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
struct gprs_data *gd = ofono_gprs_get_data(gprs);
GAtResultIter iter;
int min, max;
const char *pdp_type;
gboolean found = FALSE;
if (!ok)
goto error;
g_at_result_iter_init(&iter, result);
while (!found && g_at_result_iter_next(&iter, "+CGDCONT:")) {
gboolean in_list = FALSE;
if (!g_at_result_iter_open_list(&iter))
continue;
if (g_at_result_iter_next_range(&iter, &min, &max) == FALSE)
continue;
if (!g_at_result_iter_close_list(&iter))
continue;
if (g_at_result_iter_open_list(&iter))
in_list = TRUE;
if (!g_at_result_iter_next_string(&iter, &pdp_type))
continue;
if (in_list && !g_at_result_iter_close_list(&iter))
continue;
/* We look for IP PDPs */
if (g_str_equal(pdp_type, "IP"))
found = TRUE;
}
if (found == FALSE)
goto error;
ofono_gprs_set_cid_range(gprs, min, max);
g_at_chat_send(gd->chat, "AT+CGREG=?", cgreg_prefix,
at_cgreg_test_cb, gprs, NULL);
return;
error:
ofono_info("GPRS not supported on this device");
ofono_gprs_remove(gprs);
}
static void at_cmgl_notify(GAtResult *result, gpointer user_data)
{
struct ofono_sms *sms = user_data;
struct sms_data *data = ofono_sms_get_data(sms);
GAtResultIter iter;
const char *hexpdu;
unsigned char pdu[176];
long pdu_len;
int tpdu_len;
int index;
int status;
char buf[16];
DBG("");
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, "+CMGL:")) {
if (!g_at_result_iter_next_number(&iter, &index))
goto err;
if (!g_at_result_iter_next_number(&iter, &status))
goto err;
if (!g_at_result_iter_skip_next(&iter))
goto err;
if (!g_at_result_iter_next_number(&iter, &tpdu_len))
goto err;
/* Only MT messages */
if (status != 0 && status != 1)
continue;
hexpdu = g_at_result_pdu(result);
DBG("Found an old SMS PDU: %s, with len: %d",
hexpdu, tpdu_len);
if (strlen(hexpdu) > sizeof(pdu) * 2)
continue;
decode_hex_own_buf(hexpdu, -1, &pdu_len, 0, pdu);
ofono_sms_deliver_notify(sms, pdu, pdu_len, tpdu_len);
/* We don't buffer SMS on the SIM/ME, send along a CMGD */
snprintf(buf, sizeof(buf), "AT+CMGD=%d", index);
g_at_chat_send(data->chat, buf, none_prefix,
at_cmgd_cb, NULL, NULL);
}
return;
err:
ofono_error("Unable to parse CMGL response");
}
static void cops_numeric_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct netreg_data *nd = ofono_netreg_get_data(cbd->user);
ofono_netreg_operator_cb_t cb = cbd->cb;
GAtResultIter iter;
const char *str;
int format;
int len;
struct ofono_error error;
decode_at_error(&error, g_at_result_final_response(result));
if (!ok)
goto error;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+COPS:"))
goto error;
g_at_result_iter_skip_next(&iter);
ok = g_at_result_iter_next_number(&iter, &format);
if (ok == FALSE || format != 2)
goto error;
if (g_at_result_iter_next_string(&iter, &str) == FALSE)
goto error;
len = strspn(str, "0123456789");
if (len != 5 && len != 6)
goto error;
extract_mcc_mnc(str, nd->mcc, nd->mnc);
DBG("Cops numeric got mcc: %s, mnc: %s", nd->mcc, nd->mnc);
ok = g_at_chat_send(nd->chat, "AT+COPS=3,0", none_prefix,
NULL, NULL, NULL);
if (ok)
ok = g_at_chat_send(nd->chat, "AT+COPS?", cops_prefix,
cops_cb, cbd, NULL);
if (ok)
return;
error:
cb(&error, NULL, cbd->data);
g_free(cbd);
}
static void notify_callback(GAtResult *result, gpointer user_data)
{
GAtResultIter iter;
g_at_result_iter_init(&iter, result);
if (g_at_result_iter_next(&iter, NULL) == TRUE)
printf("%s\n", g_at_result_iter_raw_line(&iter));
printf("==> %s\n", g_at_result_final_response(result));
}
static void chld_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct slc_establish_data *sed = user_data;
struct hfp_slc_info *info = sed->info;
unsigned int ag_mpty_feature = 0;
GAtResultIter iter;
const char *str;
if (!ok)
goto error;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CHLD:"))
goto error;
if (!g_at_result_iter_open_list(&iter))
goto error;
while (g_at_result_iter_next_unquoted_string(&iter, &str)) {
if (!strcmp(str, "0"))
ag_mpty_feature |= HFP_AG_CHLD_0;
else if (!strcmp(str, "1"))
ag_mpty_feature |= HFP_AG_CHLD_1;
else if (!strcmp(str, "1x"))
ag_mpty_feature |= HFP_AG_CHLD_1x;
else if (!strcmp(str, "2"))
ag_mpty_feature |= HFP_AG_CHLD_2;
else if (!strcmp(str, "2x"))
ag_mpty_feature |= HFP_AG_CHLD_2x;
else if (!strcmp(str, "3"))
ag_mpty_feature |= HFP_AG_CHLD_3;
else if (!strcmp(str, "4"))
ag_mpty_feature |= HFP_AG_CHLD_4;
}
if (!g_at_result_iter_close_list(&iter))
goto error;
info->ag_mpty_features = ag_mpty_feature;
if ((info->ag_features & HFP_AG_FEATURE_HF_INDICATORS) &&
(info->hf_features & HFP_HF_FEATURE_HF_INDICATORS)) {
slc_establish_data_ref(sed);
g_at_chat_send(info->chat, "AT+BIND=1", none_prefix,
bind_set_cb, sed, slc_establish_data_unref);
} else
slc_established(sed);
return;
error:
slc_failed(sed);
}
static void at_cgreg_test_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
struct gprs_data *gd = ofono_gprs_get_data(gprs);
gint range[2];
GAtResultIter iter;
int cgreg1 = 0;
int cgreg2 = 0;
const char *cmd;
if (!ok)
goto error;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "+CGREG:"))
goto error;
if (!g_at_result_iter_open_list(&iter))
goto error;
while (g_at_result_iter_next_range(&iter, &range[0], &range[1])) {
if (1 >= range[0] && 1 <= range[1])
cgreg1 = 1;
if (2 >= range[0] && 2 <= range[1])
cgreg2 = 1;
}
g_at_result_iter_close_list(&iter);
if (cgreg2)
cmd = "AT+CGREG=2";
else if (cgreg1)
cmd = "AT+CGREG=1";
else
goto error;
g_at_chat_send(gd->chat, cmd, none_prefix, NULL, NULL, NULL);
g_at_chat_send(gd->chat, "AT+CGAUTO=0", none_prefix, NULL, NULL, NULL);
/* ST-E modem does not support AT+CGEREP = 2,1 */
if (gd->vendor == OFONO_VENDOR_STE)
g_at_chat_send(gd->chat, "AT+CGEREP=1,0", none_prefix,
gprs_initialized, gprs, NULL);
else
g_at_chat_send(gd->chat, "AT+CGEREP=2,1", none_prefix,
gprs_initialized, gprs, NULL);
return;
error:
ofono_info("GPRS not supported on this device");
ofono_gprs_remove(gprs);
}
static gboolean parse_sysinfo(GAtResult *result, gint *status)
{
GAtResultIter iter;
gint srv_status;
gint srv_domain;
gint roaming_status;
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "^SYSINFO:"))
return FALSE;
if (!g_at_result_iter_next_number(&iter, &srv_status))
return FALSE;
if (!g_at_result_iter_next_number(&iter, &srv_domain))
return FALSE;
if (!g_at_result_iter_next_number(&iter, &roaming_status))
return FALSE;
DBG("%d, %d, %d", srv_status, srv_domain, roaming_status);
switch (srv_status) {
case 1: /* Restricted service */
case 2: /* Service valid */
case 3: /* Restricted region service */
if (roaming_status)
*status = CDMA_NETWORK_REGISTRATION_STATUS_ROAMING;
else
*status = CDMA_NETWORK_REGISTRATION_STATUS_REGISTERED;
break;
case 0: /* No service */
case 4: /* Not registered */
default:
*status = CDMA_NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
break;
}
switch (srv_domain) {
case 0: /* No service */
*status = CDMA_NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
break;
case 1: /* Only CS */
case 2: /* Only PS */
case 3: /* CS PS */
case 4: /* CS registered, PS in searching state */
case 255: /* CDMA not supported */
break;
}
return TRUE;
}