void g_ril_request_set_initial_attach_apn(GRil *gril, const char *apn, int proto, const char *user, const char *passwd, const char *mccmnc, struct parcel *rilp) { const char *proto_str; const int auth_type = RIL_AUTH_ANY; parcel_init(rilp); parcel_w_string(rilp, apn); proto_str = ril_ofono_protocol_to_ril_string(proto); parcel_w_string(rilp, proto_str); parcel_w_int32(rilp, auth_type); parcel_w_string(rilp, user); parcel_w_string(rilp, passwd); g_ril_append_print_buf(gril, "(%s,%s,%s,%s,%s", apn, proto_str, ril_authtype_to_string(auth_type), user, passwd); if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK) { parcel_w_string(rilp, mccmnc); g_ril_append_print_buf(gril, "%s,%s)", print_buf, mccmnc); } else { g_ril_append_print_buf(gril, "%s)", print_buf); } }
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; }
static void set_data_reg_state(GRil *gril, struct reply_data_reg_state *reply, int i, const char *str) { unsigned val; char *endp; if (str == NULL || *str == '\0') goto no_val; val = (unsigned) strtoul(str, &endp, 10); if (*endp != '\0') goto no_val; switch (i) { case RDST_IX_MAXDC: /* * MTK modem does not return max_cids, string for this index * actually contains the maximum data bearer capability. */ if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK) reply->max_cids = MTK_MODEM_MAX_CIDS; else reply->max_cids = val; g_ril_append_print_buf(gril, "%s%u", print_buf, val); break; default: goto no_val; } return; no_val: g_ril_append_print_buf(gril, "%s%s", print_buf, str ? str : "(null)"); }
static void ril_sim_read_record(struct ofono_sim *sim, int fileid, int record, int length, const unsigned char *path, unsigned int path_len, ofono_sim_read_cb_t cb, void *data) { struct sim_data *sd = ofono_sim_get_data(sim); struct cb_data *cbd = cb_data_new(cb, data); struct parcel rilp; int request = RIL_REQUEST_SIM_IO; guint ret; cbd->user = sd; parcel_init(&rilp); parcel_w_int32(&rilp, CMD_READ_RECORD); parcel_w_int32(&rilp, fileid); g_ril_append_print_buf(sd->ril, "(cmd=0x%.2X,efid=0x%.4X,", CMD_GET_RESPONSE, fileid); set_path(sd, &rilp, fileid, path, path_len); parcel_w_int32(&rilp, record); /* P1 */ parcel_w_int32(&rilp, 4); /* P2 */ parcel_w_int32(&rilp, length); /* P3 */ parcel_w_string(&rilp, NULL); /* data; only req'd for writes */ parcel_w_string(&rilp, NULL); /* pin2; only req'd for writes */ parcel_w_string(&rilp, sd->aid_str); /* AID (Application ID) */ ret = g_ril_send(sd->ril, request, rilp.data, rilp.size, ril_file_io_cb, cbd, g_free); g_ril_append_print_buf(sd->ril, "%s%d,%d,%d,(null),pin2=(null),aid=%s)", print_buf, record, 4, length, sd->aid_str); g_ril_print_request(sd->ril, ret, request); parcel_free(&rilp); if (ret <= 0) { g_free(cbd); CALLBACK_WITH_FAILURE(cb, NULL, 0, data); } }
gboolean g_ril_request_sim_write_binary(GRil *gril, const struct req_sim_write_binary *req, struct parcel *rilp) { char *hex_data; int p1, p2; parcel_init(rilp); parcel_w_int32(rilp, CMD_UPDATE_BINARY); parcel_w_int32(rilp, req->fileid); g_ril_append_print_buf(gril, "(cmd=0x%02X,efid=0x%04X,", CMD_UPDATE_BINARY, req->fileid); if (set_path(gril, req->app_type, rilp, req->fileid, req->path, req->path_len) == FALSE) goto error; p1 = req->start >> 8; p2 = req->start & 0xff; hex_data = encode_hex(req->data, req->length, 0); parcel_w_int32(rilp, p1); /* P1 */ parcel_w_int32(rilp, p2); /* P2 */ parcel_w_int32(rilp, req->length); /* P3 (Lc) */ parcel_w_string(rilp, hex_data); /* data */ parcel_w_string(rilp, NULL); /* pin2; only for FDN/BDN */ parcel_w_string(rilp, req->aid_str); /* AID (Application ID) */ /* sessionId, specific to latest MTK modems (harmless for older ones) */ if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK) parcel_w_int32(rilp, 0); g_ril_append_print_buf(gril, "%s%d,%d,%d,%s,pin2=(null),aid=%s)", print_buf, p1, p2, req->length, hex_data, req->aid_str); g_free(hex_data); return TRUE; error: return FALSE; }
static void ril_pin_send_puk(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 cb_data *cbd = cb_data_new(cb, data, sim); struct parcel rilp; sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PUK; parcel_init(&rilp); parcel_w_int32(&rilp, 3); parcel_w_string(&rilp, puk); parcel_w_string(&rilp, passwd); parcel_w_string(&rilp, sd->aid_str); g_ril_append_print_buf(sd->ril, "(puk=%s,pin=%s,aid=%s)", puk, passwd, sd->aid_str); if (g_ril_send(sd->ril, RIL_REQUEST_ENTER_SIM_PUK, &rilp, ril_enter_sim_puk_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, data); }
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); }
static void ril_pin_send(struct ofono_sim *sim, const char *passwd, ofono_sim_lock_unlock_cb_t cb, void *data) { /* * TODO: This function is supposed to enter the pending password, which * might be also PIN2. So we must check the pending PIN in the future. */ struct sim_data *sd = ofono_sim_get_data(sim); struct cb_data *cbd = cb_data_new(cb, data, sim); struct parcel rilp; sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PIN; parcel_init(&rilp); parcel_w_int32(&rilp, 2); parcel_w_string(&rilp, passwd); parcel_w_string(&rilp, sd->aid_str); g_ril_append_print_buf(sd->ril, "(%s,aid=%s)", passwd, sd->aid_str); if (g_ril_send(sd->ril, RIL_REQUEST_ENTER_SIM_PIN, &rilp, ril_enter_sim_pin_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, data); }
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; }
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; } }
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; }
static void ril_call_barring_query(struct ofono_call_barring *cb, const char *lock, int cls, ofono_call_barring_query_cb_t callback, void *data) { struct barring_data *bd = ofono_call_barring_get_data(cb); struct cb_data *cbd = cb_data_new(callback, data, bd); struct parcel rilp; char svcs_str[4]; DBG("lock: %s, services to query: %d", lock, cls); FIXUP_CLS(); parcel_init(&rilp); parcel_w_int32(&rilp, 4); /* # of strings */ parcel_w_string(&rilp, lock); parcel_w_string(&rilp, ""); /* Password is empty when not needed */ snprintf(svcs_str, sizeof(svcs_str), "%d", cls); parcel_w_string(&rilp, svcs_str); parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */ g_ril_append_print_buf(bd->ril, "(%s,\"\",%s,(null))", lock, svcs_str); if (g_ril_send(bd->ril, RIL_REQUEST_QUERY_FACILITY_LOCK, &rilp, ril_call_barring_query_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(callback, -1, data); }
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_call_barring_set_passwd(struct ofono_call_barring *barr, const char *lock, const char *old_passwd, const char *new_passwd, ofono_call_barring_set_cb_t cb, void *data) { struct barring_data *bd = ofono_call_barring_get_data(barr); struct cb_data *cbd = cb_data_new(cb, data, bd); struct parcel rilp; DBG("lock %s old %s new %s", lock, old_passwd, new_passwd); parcel_init(&rilp); parcel_w_int32(&rilp, 3); /* # of strings */ parcel_w_string(&rilp, lock); parcel_w_string(&rilp, old_passwd); parcel_w_string(&rilp, new_passwd); g_ril_append_print_buf(bd->ril, "(%s,%s,%s)", lock, old_passwd, new_passwd); if (g_ril_send(bd->ril, RIL_REQUEST_CHANGE_BARRING_PASSWORD, &rilp, ril_call_barring_set_passwd_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(cb, 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_call_barring_set(struct ofono_call_barring *cb, const char *lock, int enable, const char *passwd, int cls, ofono_call_barring_set_cb_t callback, void *data) { struct barring_data *bd = ofono_call_barring_get_data(cb); struct cb_data *cbd = cb_data_new(callback, data, bd); struct parcel rilp; char svcs_str[4]; DBG("lock: %s, enable: %d, bearer class: %d", lock, enable, cls); FIXUP_CLS(); parcel_init(&rilp); parcel_w_int32(&rilp, 5); /* # of strings */ parcel_w_string(&rilp, lock); parcel_w_string(&rilp, enable ? "1" : "0"); parcel_w_string(&rilp, passwd); snprintf(svcs_str, sizeof(svcs_str), "%d", cls); parcel_w_string(&rilp, svcs_str); parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */ g_ril_append_print_buf(bd->ril, "(%s,%s,%s,%s,(null))", lock, enable ? "1" : "0", passwd, svcs_str); if (g_ril_send(bd->ril, RIL_REQUEST_SET_FACILITY_LOCK, &rilp, ril_call_barring_set_cb, cbd, g_free) > 0) return; g_free(cbd); CALLBACK_WITH_FAILURE(callback, data); }
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 gboolean send_set_radio_cap(struct radio_data *rd, int session, int phase, int ril_rats, const char *logical_modem, int status, GRilResponseFunc cb) { struct parcel rilp; int version = 1; parcel_init(&rilp); parcel_w_int32(&rilp, version); parcel_w_int32(&rilp, session); parcel_w_int32(&rilp, phase); parcel_w_int32(&rilp, ril_rats); parcel_w_string(&rilp, logical_modem); parcel_w_int32(&rilp, status); g_ril_append_print_buf(rd->ril, "(%d,%d,%d,0x%X,%s,%d)", version, session, phase, ril_rats, logical_modem, status); if (g_ril_send(rd->ril, RIL_REQUEST_SET_RADIO_CAPABILITY, &rilp, cb, rd, NULL) == 0) return FALSE; return TRUE; }
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); }
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_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); }
static void ril_send_power(struct ril_data *rd, ofono_bool_t online, GRilResponseFunc func, gpointer user_data) { struct cb_data *cbd = user_data; ofono_modem_online_cb_t cb; GDestroyNotify notify = NULL; struct parcel rilp; if (cbd != NULL) { notify = g_free; cb = cbd->cb; } DBG("(online = 1, offline = 0)): %i", online); parcel_init(&rilp); parcel_w_int32(&rilp, 1); parcel_w_int32(&rilp, online); g_ril_append_print_buf(rd->ril, "(%d)", online); if (g_ril_send(rd->ril, RIL_REQUEST_RADIO_POWER, &rilp, func, cbd, notify) == 0 && cbd != NULL) { CALLBACK_WITH_FAILURE(cb, cbd->data); g_free(cbd); } }
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 int ril_thermal_management_enable(struct ofono_modem *modem) { struct ril_data *rd = ofono_modem_get_data(modem); struct parcel rilp; int cmd_id; char buf[4]; DBG(""); parcel_init(&rilp); parcel_w_int32(&rilp, 1); /* RIL_OEM_HOOK_STRING_GET_RF_POWER_STATUS = 0x000000AB */ cmd_id = 0x000000AB; sprintf(buf, "%d", cmd_id); parcel_w_string(&rilp, buf); g_ril_append_print_buf(rd->ril, "{cmd_id=0x%02X}", cmd_id); if (g_ril_send(rd->ril, RIL_REQUEST_OEM_HOOK_STRINGS, &rilp, get_rf_power_status_cb, modem, NULL) > 0) return 0; /* Error path */ return -EIO; }
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; }
static int ril_disable(struct ofono_modem *modem) { DBusConnection *conn = ofono_dbus_get_connection(); struct ril_data *rd = ofono_modem_get_data(modem); const char *path = ofono_modem_get_path(modem); struct parcel rilp; int cmd_id; char buf[4]; DBG("%p", modem); if (g_dbus_unregister_interface(conn, path, THERMAL_MANAGEMENT_INTERFACE)) ofono_modem_remove_interface(modem, THERMAL_MANAGEMENT_INTERFACE); /* RIL_OEM_HOOK_STRING_SET_MODEM_OFF = 0x000000CF */ cmd_id = 0x000000CF; sprintf(buf, "%d", cmd_id); parcel_init(&rilp); parcel_w_int32(&rilp, 1); parcel_w_string(&rilp, buf); g_ril_append_print_buf(rd->ril, "{cmd_id=0x%02X}", cmd_id); g_ril_send(rd->ril, RIL_REQUEST_OEM_HOOK_STRINGS, &rilp, ril_send_power_off_cb, modem, NULL); return -EINPROGRESS; }
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; }
static void ril_register_manual(struct ofono_netreg *netreg, const char *mcc, const char *mnc, ofono_netreg_register_cb_t cb, void *data) { struct netreg_data *nd = ofono_netreg_get_data(netreg); struct cb_data *cbd = cb_data_new(cb, data); char buf[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1]; struct parcel rilp; int request = RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL; int ret; /* add *netreg_data to callback */ cbd->user = nd; parcel_init(&rilp); /* RIL expects a char * specifying MCCMNC of network to select */ snprintf(buf, sizeof(buf), "%s%s", mcc, mnc); parcel_w_string(&rilp, buf); ret = g_ril_send(nd->ril, request, rilp.data, rilp.size, ril_register_cb, cbd, g_free); parcel_free(&rilp); g_ril_append_print_buf(nd->ril, "(%s)", buf); g_ril_print_request(nd->ril, ret, request); /* In case of error free cbd and return the cb with failure */ if (ret <= 0) { g_free(cbd); CALLBACK_WITH_FAILURE(cb, data); } }
static void ril_ack_delivery(struct ofono_sms *sms) { struct sms_data *sd = ofono_sms_get_data(sms); struct parcel rilp; int ret; int request = RIL_REQUEST_SMS_ACKNOWLEDGE; parcel_init(&rilp); parcel_w_int32(&rilp, 2); /* Number of int32 values in array */ parcel_w_int32(&rilp, 1); /* Successful receipt */ parcel_w_int32(&rilp, 0); /* error code */ /* TODO: should ACK be sent for either of the error cases? */ /* ACK the incoming NEW_SMS */ ret = g_ril_send(sd->ril, request, rilp.data, rilp.size, ril_ack_delivery_cb, NULL, NULL); g_ril_append_print_buf(sd->ril, "(1,0)"); g_ril_print_request(sd->ril, ret, request); parcel_free(&rilp); }
static int ril_disable(struct ofono_modem *modem) { DBG("%p", modem); struct ril_data *ril = ofono_modem_get_data(modem); struct parcel rilp; int request = RIL_REQUEST_RADIO_POWER; guint ret; parcel_init(&rilp); parcel_w_int32(&rilp, 1); /* size of array */ parcel_w_int32(&rilp, 0); /* POWER=OFF */ ofono_info("%s: RIL_REQUEST_RADIO_POWER OFF", __func__); /* fire and forget i.e. not waiting for the callback*/ ret = g_ril_send(ril->modem, request, rilp.data, rilp.size, NULL, NULL, NULL); g_ril_append_print_buf(ril->modem, "(0)"); g_ril_print_request(ril->modem, ret, request); parcel_free(&rilp); /* this will trigger the cleanup of g_io_channel */ g_ril_unref(ril->modem); ril->modem = NULL; return 0; }