static void ril_call_barring_set_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_call_barring_set_cb_t cb = cbd->cb; struct barring_data *bd = cbd->user; struct parcel rilp; int retries = -1; if (message->error != RIL_E_SUCCESS) goto error; g_ril_init_parcel(message, &rilp); /* mako reply has no payload for call barring */ if (parcel_data_avail(&rilp) == 0) goto done; if (parcel_r_int32(&rilp) != 1) goto error; retries = parcel_r_int32(&rilp); if (rilp.malformed) goto error; done: g_ril_append_print_buf(bd->ril, "{%d}", retries); g_ril_print_response(bd->ril, message); CALLBACK_WITH_SUCCESS(cb, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, cbd->data); }
static void ril_call_barring_query_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_call_barring_query_cb_t cb = cbd->cb; struct barring_data *bd = cbd->user; struct parcel rilp; int bearer_class; if (message->error != RIL_E_SUCCESS) goto error; g_ril_init_parcel(message, &rilp); /* TODO: infineon returns two integers, use a quirk here */ if (parcel_r_int32(&rilp) < 1) goto error; bearer_class = parcel_r_int32(&rilp); if (bearer_class < 0 || rilp.malformed) goto error; g_ril_append_print_buf(bd->ril, "{%d}", bearer_class); g_ril_print_response(bd->ril, message); CALLBACK_WITH_SUCCESS(cb, bearer_class, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, -1, cbd->data); }
static void ril_radio_state_changed(struct ril_msg *message, gpointer user_data) { struct ofono_modem *modem = user_data; struct ril_data *rd = ofono_modem_get_data(modem); struct parcel rilp; int radio_state; g_ril_init_parcel(message, &rilp); radio_state = parcel_r_int32(&rilp); if (rilp.malformed) { ofono_error("%s: malformed parcel received", __func__); ofono_modem_set_powered(modem, FALSE); return; } g_ril_append_print_buf(rd->ril, "(state: %s)", ril_radio_state_to_string(radio_state)); g_ril_print_unsol(rd->ril, message); switch (radio_state) { case RADIO_STATE_ON: break; case RADIO_STATE_UNAVAILABLE: ofono_modem_set_powered(modem, FALSE); break; case RADIO_STATE_OFF: break; } }
static gboolean parse_sim_io(GRil *ril, struct ril_msg *message, int *sw1, int *sw2, char **hex_response) { struct parcel rilp; /* * Minimum length of SIM_IO_Response is 12: * sw1 (int32) * sw2 (int32) * simResponse (string) */ if (message->buf_len < 12) { ofono_error("Invalid SIM IO reply: size too small (< 12): %u", message->buf_len); return FALSE; } g_ril_init_parcel(message, &rilp); *sw1 = parcel_r_int32(&rilp); *sw2 = parcel_r_int32(&rilp); *hex_response = parcel_r_string(&rilp); g_ril_append_print_buf(ril, "(sw1=0x%.2X,sw2=0x%.2X,%s)", *sw1, *sw2, *hex_response); g_ril_print_response(ril, message); if (rilp.malformed) { g_free(*hex_response); return FALSE; } return TRUE; }
struct parcel_str_array *g_ril_reply_oem_hook_strings(GRil *gril, const struct ril_msg *message) { struct parcel rilp; struct parcel_str_array *str_arr; int i; g_ril_init_parcel(message, &rilp); str_arr = parcel_r_str_array(&rilp); if (str_arr == NULL) { ofono_error("%s: no strings", __func__); goto out; } g_ril_append_print_buf(gril, "{"); for (i = 0; i < str_arr->num_str; ++i) { if (i + 1 == str_arr->num_str) g_ril_append_print_buf(gril, "%s%s}", print_buf, str_arr->str[i]); else g_ril_append_print_buf(gril, "%s%s, ", print_buf, str_arr->str[i]); } g_ril_print_response(gril, message); out: return str_arr; }
int g_ril_reply_parse_query_facility_lock(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int status, numint; g_ril_init_parcel(message, &rilp); /* infineon returns two integers */ numint = parcel_r_int32(&rilp); if (numint < 1) { ofono_error("%s: wrong format", __func__); goto error; } status = parcel_r_int32(&rilp); if (rilp.malformed) { ofono_error("%s: malformed parcel", __func__); goto error; } g_ril_append_print_buf(gril, "{%d}", status); g_ril_print_response(gril, message); return status; error: return -1; }
int g_ril_reply_parse_set_facility_lock(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int retries = -1, numint; g_ril_init_parcel(message, &rilp); /* mako reply has no payload for call barring */ if (parcel_data_avail(&rilp) == 0) goto end; numint = parcel_r_int32(&rilp); if (numint != 1) { ofono_error("%s: wrong format", __func__); goto end; } retries = parcel_r_int32(&rilp); if (rilp.malformed) { ofono_error("%s: malformed parcel", __func__); goto end; } end: g_ril_append_print_buf(gril, "{%d}", retries); g_ril_print_response(gril, message); return retries; }
static void ril_query_facility_lock_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_query_facility_lock_cb_t cb = cbd->cb; struct sim_data *sd = cbd->user; struct parcel rilp; ofono_bool_t status; int numparams; if (message->error != RIL_E_SUCCESS) goto error; g_ril_init_parcel(message, &rilp); numparams = parcel_r_int32(&rilp); if (numparams < 1) goto error; status = (ofono_bool_t) parcel_r_int32(&rilp); g_ril_append_print_buf(sd->ril, "{%d}", status); g_ril_print_response(sd->ril, message); CALLBACK_WITH_SUCCESS(cb, status, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, 0, cbd->data); }
static void ril_imsi_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_sim_imsi_cb_t cb = cbd->cb; struct sim_data *sd = cbd->user; struct parcel rilp; gchar *imsi; DBG(""); if (message->error != RIL_E_SUCCESS) { ofono_error("Reply failure: %s", ril_error_to_string(message->error)); goto error; } g_ril_init_parcel(message, &rilp); imsi = parcel_r_string(&rilp); g_ril_append_print_buf(sd->ril, "{%s}", imsi ? imsi : "NULL"); g_ril_print_response(sd->ril, message); if (imsi == NULL) goto error; CALLBACK_WITH_SUCCESS(cb, imsi, cbd->data); g_free(imsi); return; error: CALLBACK_WITH_FAILURE(cb, NULL, cbd->data); }
int g_ril_reply_parse_sms_response(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int error, mr; char *ack_pdu; /* Set up Parcel struct for proper parsing */ g_ril_init_parcel(message, &rilp); /* * TP-Message-Reference for GSM/ * BearerData MessageId for CDMA */ mr = parcel_r_int32(&rilp); ack_pdu = parcel_r_string(&rilp); error = parcel_r_int32(&rilp); g_ril_append_print_buf(gril, "{%d,%s,%d}", mr, ack_pdu, error); g_ril_print_response(gril, message); g_free(ack_pdu); return mr; }
static void ril_enter_sim_puk_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_sim_lock_unlock_cb_t cb = cbd->cb; struct ofono_sim *sim = cbd->user; struct sim_data *sd = ofono_sim_get_data(sim); struct parcel rilp; g_ril_init_parcel(message, &rilp); parcel_r_int32(&rilp); if (message->error != RIL_E_SUCCESS) { sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = parcel_r_int32(&rilp); } else { sd->retries[OFONO_SIM_PASSWORD_SIM_PIN] = -1; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = -1; } g_ril_append_print_buf(sd->ril, "{%d}", sd->retries[OFONO_SIM_PASSWORD_SIM_PUK]); g_ril_print_response(sd->ril, message); if (message->error == RIL_E_SUCCESS) { CALLBACK_WITH_SUCCESS(cb, cbd->data); return; } CALLBACK_WITH_FAILURE(cb, cbd->data); }
int g_ril_reply_parse_query_call_waiting(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int numint, enabled, cls; g_ril_init_parcel(message, &rilp); numint = parcel_r_int32(&rilp); if (numint < 1) { ofono_error("%s Wrong format", __func__); goto error; } enabled = parcel_r_int32(&rilp); if (enabled > 0) cls = parcel_r_int32(&rilp); else cls = 0; g_ril_append_print_buf(gril, "{%d,0x%x}", enabled, cls); g_ril_print_response(gril, message); return cls; error: return -1; }
struct unsol_supp_svc_notif *g_ril_unsol_parse_supp_svc_notif(GRil *gril, struct ril_msg *message) { struct parcel rilp; char *tmp_number; int type; struct unsol_supp_svc_notif *unsol = g_new0(struct unsol_supp_svc_notif, 1); g_ril_init_parcel(message, &rilp); unsol->notif_type = parcel_r_int32(&rilp); unsol->code = parcel_r_int32(&rilp); unsol->index = parcel_r_int32(&rilp); type = parcel_r_int32(&rilp); tmp_number = parcel_r_string(&rilp); if (tmp_number != NULL) { strncpy(unsol->number.number, tmp_number, OFONO_MAX_PHONE_NUMBER_LENGTH); unsol->number.type = type; g_free(tmp_number); } g_ril_append_print_buf(gril, "{%d,%d,%d,%d,%s}", unsol->notif_type, unsol->code, unsol->index, type, tmp_number); g_ril_print_unsol(gril, message); return unsol; }
int g_ril_unsol_parse_connected(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int size; int version; DBG(""); g_ril_init_parcel(message, &rilp); size = parcel_r_int32(&rilp); version = parcel_r_int32(&rilp); /* * For something that looks like a bug we get an extra int in mtk2 * modems. RIL version is the second integer in this case. This * happens when we get duplicated connected events, which should * not happen either. In these cases the first event has the right * size, but not those appearing after. */ if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK2 && size > 1) version = parcel_r_int32(&rilp); if (rilp.malformed) { ofono_error("%s: malformed parcel", __func__); version = RIL_VERSION_UNSPECIFIED; } g_ril_append_print_buf(gril, "{size: %d, [%d]}", size, version); g_ril_print_unsol(gril, message); return version; }
static void ril_ussd_notify(struct ril_msg *message, gpointer user_data) { struct ofono_ussd *ussd = user_data; struct ussd_data *ud = ofono_ussd_get_data(ussd); struct parcel rilp; int numstr; char *typestr; int type; char *str = NULL; gsize written; char *ucs2; g_ril_init_parcel(message, &rilp); numstr = parcel_r_int32(&rilp); if (numstr < 1) return; typestr = parcel_r_string(&rilp); if (typestr == NULL || *typestr == '\0') return; type = *typestr - '0'; g_free(typestr); if (numstr > 1) str = parcel_r_string(&rilp); g_ril_append_print_buf(ud->ril, "{%d,%s}", type, str); g_ril_print_unsol(ud->ril, message); /* To fix bug in MTK: USSD-Notify arrive with type 2 instead of 0 */ if (g_ril_vendor(ud->ril) == OFONO_RIL_VENDOR_MTK && str != NULL && type == 2) type = 0; if (str == NULL) { ofono_ussd_notify(ussd, type, 0, NULL, 0); return; } /* * With data coding scheme 0x48, we are saying that the ussd string is a * UCS-2 string, uncompressed, and with unspecified message class. For * the DCS coding, see 3gpp 23.038, sect. 5. */ ucs2 = g_convert(str, -1, "UCS-2BE//TRANSLIT", "UTF-8", NULL, &written, NULL); g_free(str); if (ucs2 == NULL) { ofono_error("%s: Error transcoding", __func__); return; } ofono_ussd_notify(ussd, type, 0x48, (unsigned char *) ucs2, written); g_free(ucs2); }
static void ril_radio_state_changed(struct ril_msg *message, gpointer user_data) { struct ofono_modem *modem = user_data; struct ril_data *rd = ofono_modem_get_data(modem); struct parcel rilp; int radio_state; g_ril_init_parcel(message, &rilp); radio_state = parcel_r_int32(&rilp); if (rilp.malformed) { ofono_error("%s: malformed parcel received", __func__); ofono_modem_set_powered(modem, FALSE); return; } g_ril_append_print_buf(rd->ril, "(state: %s)", ril_radio_state_to_string(radio_state)); g_ril_print_unsol(rd->ril, message); if (radio_state != rd->radio_state) { ofono_info("%s: state: %s rd->ofono_online: %d", __func__, ril_radio_state_to_string(radio_state), rd->ofono_online); rd->radio_state = radio_state; switch (radio_state) { case RADIO_STATE_ON: if (rd->radio_settings == NULL) rd->radio_settings = ofono_radio_settings_create(modem, rd->vendor, RILMODEM, rd->ril); break; case RADIO_STATE_UNAVAILABLE: case RADIO_STATE_OFF: /* * Unexpected radio state change, as we are supposed to * be online. UNAVAILABLE has been seen occassionally * when powering off the phone. We wait 5 secs to avoid * too fast re-spawns, then exit with error to make * upstart re-start ofono. */ if (rd->ofono_online) ofono_error("%s: radio self-powered off!", __func__); break; } } }
struct ofono_phone_number *g_ril_reply_parse_get_smsc_address( GRil *gril, const struct ril_msg *message) { struct ofono_phone_number *sca; struct parcel rilp; char *number, *temp_buf; sca = g_new0(struct ofono_phone_number, 1); if (sca == NULL) { ofono_error("%s Out of memory", __func__); goto err_alloc; } g_ril_init_parcel(message, &rilp); temp_buf = parcel_r_string(&rilp); if (temp_buf == NULL) { ofono_error("%s Cannot read SMSC address", __func__); goto err_readsca; } /* RIL gives address in quotes */ number = strtok(temp_buf, "\""); if (number == NULL || *number == '\0') { ofono_error("%s Invalid SMSC address", __func__); goto err_scaformat; } if (number[0] == '+') { number = number + 1; sca->type = OFONO_NUMBER_TYPE_INTERNATIONAL; } else { sca->type = OFONO_NUMBER_TYPE_UNKNOWN; } strncpy(sca->number, number, OFONO_MAX_PHONE_NUMBER_LENGTH); sca->number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0'; g_ril_append_print_buf(gril, "{type=%d,number=%s}", sca->type, sca->number); g_ril_print_response(gril, message); g_free(temp_buf); return sca; err_scaformat: g_free(temp_buf); err_readsca: g_free(sca); err_alloc: return NULL; }
struct reply_sim_io *g_ril_reply_parse_sim_io(GRil *gril, const struct ril_msg *message) { struct parcel rilp; char *response = NULL; struct reply_sim_io *reply; /* * Minimum length of SIM_IO_Response is 12: * sw1 (int32) * sw2 (int32) * simResponse (string) */ if (message->buf_len < 12) { ofono_error("Invalid SIM IO reply: size too small (< 12): %d ", (int) message->buf_len); return NULL; } reply = g_new0(struct reply_sim_io, 1); g_ril_init_parcel(message, &rilp); reply->sw1 = parcel_r_int32(&rilp); reply->sw2 = parcel_r_int32(&rilp); response = parcel_r_string(&rilp); g_ril_append_print_buf(gril, "(sw1=0x%.2X,sw2=0x%.2X,%s)", reply->sw1, reply->sw2, response); g_ril_print_response(gril, message); if (rilp.malformed) goto error; if (response != NULL) { reply->hex_response = decode_hex(response, strlen(response), (long *) &reply->hex_len, -1); g_free(response); if (reply->hex_response == NULL) goto error; } return reply; error: g_free(reply); return NULL; }
int g_ril_reply_parse_get_preferred_network_type(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int numint, parcel_net_type, net_type; g_ril_init_parcel(message, &rilp); numint = parcel_r_int32(&rilp); if (numint != 1) { ofono_error("%s: Wrong format", __func__); goto error; } parcel_net_type = parcel_r_int32(&rilp); net_type = parcel_net_type; /* Try to translate special MTK settings */ if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK) { switch (net_type) { /* 4G preferred */ case MTK_PREF_NET_TYPE_LTE_GSM_WCDMA: case MTK_PREF_NET_TYPE_LTE_GSM_WCDMA_MMDC: case MTK_PREF_NET_TYPE_LTE_GSM_TYPE: case MTK_PREF_NET_TYPE_LTE_GSM_MMDC_TYPE: net_type = PREF_NET_TYPE_LTE_GSM_WCDMA; break; /* 3G or 2G preferred over LTE */ case MTK_PREF_NET_TYPE_GSM_WCDMA_LTE: case MTK_PREF_NET_TYPE_GSM_WCDMA_LTE_MMDC: net_type = PREF_NET_TYPE_GSM_WCDMA; break; } } if (net_type < 0 || net_type > PREF_NET_TYPE_LTE_ONLY) { ofono_error("%s: unknown network type", __func__); goto error; } if (rilp.malformed) { ofono_error("%s: malformed parcel", __func__); goto error; } g_ril_append_print_buf(gril, "{%d}", parcel_net_type); g_ril_print_response(gril, message); return net_type; error: return -1; }
static void inf_pin_retries_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_sim_pin_retries_cb_t cb = cbd->cb; struct sim_data *sd = cbd->user; struct parcel rilp; int32_t *data; int len; char *hex_dump; int expected; DBG(""); if (message->error != RIL_E_SUCCESS) { ofono_error("Reply failure: %s", ril_error_to_string(message->error)); goto error; } g_ril_init_parcel(message, &rilp); data = parcel_r_raw(&rilp, &len); if (data == NULL) { ofono_error("%s: malformed parcel", __func__); goto error; } hex_dump = encode_hex((unsigned char *) data, len, '\0'); g_ril_append_print_buf(sd->ril, "{%d,%s}", len, hex_dump); g_ril_print_response(sd->ril, message); g_free(hex_dump); expected = sizeof(int32_t) * 5; if (len < expected) { ofono_error("%s: reply too small", __func__); g_free(data); goto error; } /* First integer is INF_RIL_REQUEST_OEM_GET_REMAIN_SIM_PIN_ATTEMPTS */ sd->retries[OFONO_SIM_PASSWORD_SIM_PIN] = data[1]; sd->retries[OFONO_SIM_PASSWORD_SIM_PIN2] = data[2]; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = data[3]; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK2] = data[4]; g_free(data); CALLBACK_WITH_SUCCESS(cb, sd->retries, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, NULL, cbd->data); }
gchar *g_ril_reply_parse_imsi(GRil *gril, const struct ril_msg *message) { struct parcel rilp; gchar *imsi; g_ril_init_parcel(message, &rilp); imsi = parcel_r_string(&rilp); g_ril_append_print_buf(gril, "{%s}", imsi ? imsi : "NULL"); g_ril_print_response(gril, message); return imsi; }
static void mtk_pin_retries_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_sim_pin_retries_cb_t cb = cbd->cb; struct sim_data *sd = cbd->user; struct parcel rilp; char **strv; char *debug_str; int pin[MTK_EPINC_NUM_PASSWD]; int num_pin; if (message->error != RIL_E_SUCCESS) { ofono_error("Reply failure: %s", ril_error_to_string(message->error)); goto error; } g_ril_init_parcel(message, &rilp); strv = parcel_r_strv(&rilp); if (strv == NULL) { ofono_error("%s: parse error", __func__); goto error; } debug_str = g_strjoinv(",", strv); g_ril_append_print_buf(sd->ril, "{%d,%s}", g_strv_length(strv), debug_str); g_free(debug_str); g_ril_print_response(sd->ril, message); num_pin = sscanf(strv[0], "+EPINC:%d,%d,%d,%d", &pin[0], &pin[1], &pin[2], &pin[3]); g_strfreev(strv); if (num_pin != MTK_EPINC_NUM_PASSWD) goto error; sd->retries[OFONO_SIM_PASSWORD_SIM_PIN] = pin[0]; sd->retries[OFONO_SIM_PASSWORD_SIM_PIN2] = pin[1]; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = pin[2]; sd->retries[OFONO_SIM_PASSWORD_SIM_PUK2] = pin[3]; CALLBACK_WITH_SUCCESS(cb, sd->retries, cbd->data); return; error: CALLBACK_WITH_FAILURE(cb, NULL, cbd->data); }
char *g_ril_reply_parse_baseband_version(GRil *gril, const struct ril_msg *message) { struct parcel rilp; char *version; g_ril_init_parcel(message, &rilp); version = parcel_r_string(&rilp); g_ril_append_print_buf(gril, "{%s}", version); g_ril_print_response(gril, message); return version; }
struct unsol_ussd *g_ril_unsol_parse_ussd(GRil *gril, struct ril_msg *message) { struct parcel rilp; struct unsol_ussd *ussd; char *typestr = NULL; int numstr; ussd = g_try_malloc0(sizeof(*ussd)); if (ussd == NULL) { ofono_error("%s out of memory", __func__); goto error; } g_ril_init_parcel(message, &rilp); numstr = parcel_r_int32(&rilp); if (numstr < 1) { ofono_error("%s malformed parcel", __func__); goto error; } typestr = parcel_r_string(&rilp); if (typestr == NULL || *typestr == '\0') { ofono_error("%s wrong type", __func__); goto error; } ussd->type = *typestr - '0'; g_free(typestr); if (numstr > 1) ussd->message = parcel_r_string(&rilp); g_ril_append_print_buf(gril, "{%d,%s}", ussd->type, ussd->message); g_ril_print_unsol(gril, message); return ussd; error: g_free(typestr); g_free(ussd); return NULL; }
int g_ril_reply_parse_get_mute(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int muted; g_ril_init_parcel(message, &rilp); /* skip length of int[] */ parcel_r_int32(&rilp); muted = parcel_r_int32(&rilp); g_ril_append_print_buf(gril, "{%d}", muted); g_ril_print_response(gril, message); return muted; }
gchar *g_ril_reply_parse_imsi(GRil *gril, const struct ril_msg *message) { struct parcel rilp; gchar *imsi; g_ril_init_parcel(message, &rilp); /* 15 is the max length of IMSI * add 4 bytes for string length */ /* FIXME: g_assert(message->buf_len <= 19); */ imsi = parcel_r_string(&rilp); g_ril_append_print_buf(gril, "{%s}", imsi); g_ril_print_response(gril, message); return imsi; }
struct unsol_sms_data *g_ril_unsol_parse_new_sms(GRil *gril, const struct ril_msg *message) { struct parcel rilp; char *ril_pdu; size_t ril_pdu_len; struct unsol_sms_data *sms_data; sms_data = g_new0(struct unsol_sms_data, 1); if (sms_data == NULL) { ofono_error("%s out of memory", __func__); goto error; } g_ril_init_parcel(message, &rilp); ril_pdu = parcel_r_string(&rilp); if (ril_pdu == NULL) { ofono_error("%s Unable to parse notification", __func__); goto error; } ril_pdu_len = strlen(ril_pdu); sms_data->data = decode_hex(ril_pdu, ril_pdu_len, &sms_data->length, -1); if (sms_data->data == NULL) { ofono_error("%s Unable to decode notification", __func__); goto error_dec; } g_ril_append_print_buf(gril, "{%s}", ril_pdu); g_ril_print_unsol(gril, message); g_free(ril_pdu); return sms_data; error_dec: g_free(ril_pdu); error: g_ril_unsol_free_sms_data(sms_data); return NULL; }
static void ril_enter_sim_pin_cb(struct ril_msg *message, gpointer user_data) { struct cb_data *cbd = user_data; ofono_sim_lock_unlock_cb_t cb = cbd->cb; struct ofono_sim *sim = cbd->user; struct sim_data *sd = ofono_sim_get_data(sim); struct parcel rilp; /* * There is no reason to ask SIM status until * unsolicited sim status change indication * Looks like state does not change before that. */ DBG("Enter password: type %d, result %d", sd->passwd_type, message->error); g_ril_init_parcel(message, &rilp); parcel_r_int32(&rilp); if (message->error == RIL_E_SUCCESS) sd->retries[sd->passwd_type] = -1; else sd->retries[sd->passwd_type] = parcel_r_int32(&rilp); g_ril_append_print_buf(sd->ril, "{%d}", sd->retries[sd->passwd_type]); g_ril_print_response(sd->ril, message); if (message->error == RIL_E_SUCCESS) { CALLBACK_WITH_SUCCESS(cb, cbd->data); return; } CALLBACK_WITH_FAILURE(cb, cbd->data); /* * Refresh passwd_state (not needed if the unlock is * successful, as an event will refresh the state in that case) */ send_get_sim_status(sim); }
static void probe_mute_cb(struct ril_msg *message, gpointer user_data) { struct ofono_call_volume *cv = user_data; struct cv_data *cvd = ofono_call_volume_get_data(cv); struct parcel rilp; int muted; if (message->error != RIL_E_SUCCESS) return; g_ril_init_parcel(message, &rilp); /* skip length of int[] */ parcel_r_int32(&rilp); muted = parcel_r_int32(&rilp); g_ril_append_print_buf(cvd->ril, "{%d}", muted); g_ril_print_response(cvd->ril, message); ofono_call_volume_set_muted(cv, muted); }
int g_ril_unsol_parse_radio_state_changed(GRil *gril, const struct ril_msg *message) { struct parcel rilp; int radio_state; g_ril_init_parcel(message, &rilp); radio_state = parcel_r_int32(&rilp); if (rilp.malformed) { ofono_error("%s: malformed parcel received", __func__); radio_state = -1; } g_ril_append_print_buf(gril, "(state: %s)", ril_radio_state_to_string(radio_state)); g_ril_print_unsol(gril, message); return radio_state; }