gboolean g_ril_request_sim_read_record(GRil *gril,
const struct req_sim_read_record *req,
struct parcel *rilp)
{
parcel_init(rilp);
parcel_w_int32(rilp, CMD_READ_RECORD);
parcel_w_int32(rilp, req->fileid);
g_ril_append_print_buf(gril,
"(cmd=0x%.2X,efid=0x%.4X,",
CMD_READ_RECORD,
req->fileid);
if (set_path(gril, req->app_type, rilp, req->fileid,
req->path, req->path_len) == FALSE)
goto error;
parcel_w_int32(rilp, req->record); /* P1 */
parcel_w_int32(rilp, 4); /* P2 */
parcel_w_int32(rilp, req->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, req->aid_str); /* AID (Application ID) */
return TRUE;
error:
return FALSE;
}
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_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);
struct parcel rilp;
int ret = 0;
DBG("");
parcel_init(&rilp);
parcel_w_int32(&rilp, RIL_SET_PW_STRING_COUNT); /* Nbr of strings */
parcel_w_string(&rilp, (char *) lock); /* Facility code */
parcel_w_string(&rilp, (char *) old_passwd);
parcel_w_string(&rilp, (char *) new_passwd);
ret = g_ril_send(bd->ril, RIL_REQUEST_CHANGE_BARRING_PASSWORD,
rilp.data, rilp.size, ril_call_barring_set_passwd_cb,
cbd, g_free);
parcel_free(&rilp);
if (ret <= 0) {
ofono_error("Sending Call Barring Set PW req failed, err: %i",
ret);
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
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);
}
}
gboolean g_ril_request_sim_read_record(GRil *gril,
const struct req_sim_read_record *req,
struct parcel *rilp)
{
parcel_init(rilp);
parcel_w_int32(rilp, CMD_READ_RECORD);
parcel_w_int32(rilp, req->fileid);
g_ril_append_print_buf(gril,
"(cmd=0x%.2X,efid=0x%.4X,",
CMD_READ_RECORD,
req->fileid);
if (set_path(gril, req->app_type, rilp, req->fileid,
req->path, req->path_len) == FALSE)
goto error;
parcel_w_int32(rilp, req->record); /* P1 */
parcel_w_int32(rilp, 4); /* P2 */
parcel_w_int32(rilp, req->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, 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);
return TRUE;
error:
return FALSE;
}
static void ril_pin_send(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 cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
int request = RIL_REQUEST_ENTER_SIM_PIN;
int ret;
sd->passwd_type = OFONO_SIM_PASSWORD_SIM_PIN;
cbd->user = sd;
if (current_passwd)
g_stpcpy(current_passwd, passwd);
parcel_init(&rilp);
parcel_w_int32(&rilp, ENTER_SIM_PIN_PARAMS);
parcel_w_string(&rilp, (char *) passwd);
parcel_w_string(&rilp, sd->aid_str);
ret = g_ril_send(sd->ril, request,
rilp.data, rilp.size, ril_pin_change_state_cb,
cbd, g_free);
g_ril_append_print_buf(sd->ril, "(%s,aid=%s)", passwd, sd->aid_str);
g_ril_print_request(sd->ril, ret, request);
parcel_free(&rilp);
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
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(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);
}
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 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);
}
gboolean g_ril_request_sim_read_binary(GRil *gril,
const struct req_sim_read_binary *req,
struct parcel *rilp)
{
g_ril_append_print_buf(gril,
"(cmd=0x%.2X,efid=0x%.4X,",
CMD_READ_BINARY,
req->fileid);
parcel_init(rilp);
parcel_w_int32(rilp, CMD_READ_BINARY);
parcel_w_int32(rilp, req->fileid);
if (set_path(gril, req->app_type, rilp, req->fileid,
req->path, req->path_len) == FALSE)
goto error;
parcel_w_int32(rilp, (req->start >> 8)); /* P1 */
parcel_w_int32(rilp, (req->start & 0xff)); /* P2 */
parcel_w_int32(rilp, req->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, req->aid_str);
return TRUE;
error:
return FALSE;
}
static void ril_cmgs(struct ofono_sms *sms, const unsigned char *pdu,
int pdu_len, int tpdu_len, int mms,
ofono_sms_submit_cb_t cb, void *user_data)
{
struct sms_data *sd = ofono_sms_get_data(sms);
struct cb_data *cbd = cb_data_new(cb, user_data);
struct parcel rilp;
char *tpdu;
int request = RIL_REQUEST_SEND_SMS;
int ret, smsc_len;
cbd->user = sd;
DBG("pdu_len: %d, tpdu_len: %d mms: %d", pdu_len, tpdu_len, mms);
/* TODO: if (mms) { ... } */
parcel_init(&rilp);
parcel_w_int32(&rilp, 2); /* Number of strings */
/* SMSC address:
*
* smsc_len == 1, then zero-length SMSC was spec'd
* RILD expects a NULL string in this case instead
* of a zero-length string.
*/
smsc_len = pdu_len - tpdu_len;
if (smsc_len > 1) {
/* TODO: encode SMSC & write to parcel */
DBG("SMSC address specified (smsc_len %d); NOT-IMPLEMENTED", smsc_len);
}
parcel_w_string(&rilp, NULL); /* SMSC address; NULL == default */
/* TPDU:
*
* 'pdu' is a raw hexadecimal string
* encode_hex() turns it into an ASCII/hex UTF8 buffer
* parcel_w_string() encodes utf8 -> utf16
*/
tpdu = encode_hex(pdu + smsc_len, tpdu_len, 0);
parcel_w_string(&rilp, tpdu);
ret = g_ril_send(sd->ril,
request,
rilp.data,
rilp.size,
submit_sms_cb, cbd, g_free);
g_ril_append_print_buf(sd->ril, "(%s)", tpdu);
g_ril_print_request(sd->ril, ret, request);
parcel_free(&rilp);
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, -1, user_data);
}
}
static void ril_sim_update_binary(struct ofono_sim *sim, int fileid,
int start, int length,
const unsigned char *value,
const unsigned char *path,
unsigned int path_len,
ofono_sim_write_cb_t cb, void *data)
{
struct sim_data *sd = ofono_sim_get_data(sim);
struct cb_data *cbd = cb_data_new(cb, data, sd);
char *hex_path;
struct parcel rilp;
char *hex_data;
int p1, p2;
DBG("file 0x%04x", fileid);
hex_path = get_path(g_ril_vendor(sd->ril),
sd->app_type, fileid, path, path_len);
if (hex_path == NULL) {
ofono_error("Couldn't build SIM read info request - NULL path");
goto error;
}
p1 = start >> 8;
p2 = start & 0xff;
hex_data = encode_hex(value, length, 0);
parcel_init(&rilp);
parcel_w_int32(&rilp, CMD_UPDATE_BINARY);
parcel_w_int32(&rilp, fileid);
parcel_w_string(&rilp, hex_path);
parcel_w_int32(&rilp, p1); /* P1 */
parcel_w_int32(&rilp, p2); /* P2 */
parcel_w_int32(&rilp, length); /* P3 (Lc) */
parcel_w_string(&rilp, hex_data); /* data */
parcel_w_string(&rilp, NULL); /* pin2; only for FDN/BDN */
parcel_w_string(&rilp, sd->aid_str); /* AID (Application ID) */
/* sessionId, specific to latest MTK modems (harmless for older ones) */
if (g_ril_vendor(sd->ril) == OFONO_RIL_VENDOR_MTK)
parcel_w_int32(&rilp, 0);
g_ril_append_print_buf(sd->ril, "(cmd=0x%02X,efid=0x%04X,path=%s,"
"%d,%d,%d,%s,pin2=(null),aid=%s),",
CMD_UPDATE_BINARY, fileid, hex_path,
p1, p2, length, hex_data, sd->aid_str);
g_free(hex_path);
g_free(hex_data);
if (g_ril_send(sd->ril, RIL_REQUEST_SIM_IO, &rilp,
ril_file_write_cb, cbd, g_free) > 0)
return;
error:
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
static void set_path(struct sim_data *sd, struct parcel *rilp,
const int fileid, const guchar *path,
const guint path_len)
{
guchar db_path[6] = { 0x00 };
char *hex_path = NULL;
int len = 0;
DBG("");
if (path_len > 0 && path_len < 7) {
memcpy(db_path, path, path_len);
len = path_len;
} else if (sd->app_type == RIL_APPTYPE_USIM) {
len = sim_ef_db_get_path_3g(fileid, db_path);
} else if (sd->app_type == RIL_APPTYPE_SIM) {
len = sim_ef_db_get_path_2g(fileid, db_path);
} else {
ofono_error("Unsupported app_type: 0%x", sd->app_type);
}
if (len > 0) {
hex_path = encode_hex(db_path, len, 0);
parcel_w_string(rilp, (char *) hex_path);
g_ril_append_print_buf(sd->ril,
"%spath=%s,",
print_buf,
hex_path);
g_free(hex_path);
} else if (fileid == SIM_EF_ICCID_FILEID || fileid == SIM_EFPL_FILEID) {
/*
* Special catch-all for EF_ICCID (unique card ID)
* and EF_PL files which exist in the root directory.
* As the sim_info_cb function may not have yet
* recorded the app_type for the SIM, and the path
* for both files is the same for 2g|3g, just hard-code.
*
* See 'struct ef_db' in:
* ../../src/simutil.c for more details.
*/
parcel_w_string(rilp, (char *) ROOTMF);
} else {
/*
* The only known case of this is EFPHASE_FILED (0x6FAE).
* The ef_db table ( see /src/simutil.c ) entry for
* EFPHASE contains a value of 0x0000 for it's
* 'parent3g' member. This causes a NULL path to
* be returned.
*/
DBG("db_get_path*() returned empty path.");
parcel_w_string(rilp, 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);
}
}
void g_ril_request_pin_send(GRil *gril,
const char *passwd,
const gchar *aid_str,
struct parcel *rilp)
{
parcel_init(rilp);
parcel_w_int32(rilp, ENTER_SIM_PIN_PARAMS);
parcel_w_string(rilp, passwd);
parcel_w_string(rilp, aid_str);
g_ril_append_print_buf(gril, "(%s,aid=%s)", passwd, aid_str);
}
static void ril_sim_read_binary(struct ofono_sim *sim, int fileid,
int start, 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, sd);
char *hex_path;
struct parcel rilp;
DBG("file %04x", fileid);
hex_path = get_path(g_ril_vendor(sd->ril),
sd->app_type, fileid, path, path_len);
if (hex_path == NULL) {
ofono_error("Couldn't build SIM read info request - NULL path");
goto error;
}
parcel_init(&rilp);
parcel_w_int32(&rilp, CMD_READ_BINARY);
parcel_w_int32(&rilp, fileid);
parcel_w_string(&rilp, hex_path);
parcel_w_int32(&rilp, start >> 8); /* P1 */
parcel_w_int32(&rilp, start & 0xff); /* 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);
/* sessionId, specific to latest MTK modems (harmless for older ones) */
if (g_ril_vendor(sd->ril) == OFONO_RIL_VENDOR_MTK)
parcel_w_int32(&rilp, 0);
g_ril_append_print_buf(sd->ril, "(cmd=0x%.2X,efid=0x%.4X,path=%s,"
"%d,%d,%d,(null),pin2=(null),aid=%s)",
CMD_READ_BINARY, fileid, hex_path,
start >> 8, start & 0xff,
length, sd->aid_str);
g_free(hex_path);
if (g_ril_send(sd->ril, RIL_REQUEST_SIM_IO, &rilp,
ril_file_io_cb, cbd, g_free) > 0)
return;
error:
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;
}
void g_ril_request_change_barring_password(GRil *gril, const char *facility,
const char *old_passwd,
const char *new_passwd,
struct parcel *rilp)
{
parcel_init(rilp);
parcel_w_int32(rilp, 3); /* # of strings */
parcel_w_string(rilp, facility);
parcel_w_string(rilp, old_passwd);
parcel_w_string(rilp, new_passwd);
g_ril_append_print_buf(gril, "(%s,%s,%s)",
facility, old_passwd, new_passwd);
}
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;
}
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_send_dtmf(struct ofono_voicecall *vc, const char *dtmf,
ofono_voicecall_cb_t cb, void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
int len = strlen(dtmf);
struct parcel rilp;
struct ofono_error error;
char *ril_dtmf = g_try_malloc(sizeof(char) * 2);
int i;
DBG("");
/* Ril wants just one character, but we need to send as string */
ril_dtmf[1] = '\0';
for (i = 0; i < len; i++) {
parcel_init(&rilp);
ril_dtmf[0] = dtmf[i];
parcel_w_string(&rilp, ril_dtmf);
DBG("DTMF: Sending %s", ril_dtmf);
g_ril_send(vd->ril, RIL_REQUEST_DTMF, rilp.data,
rilp.size, NULL, NULL, NULL);
parcel_free(&rilp);
}
free(ril_dtmf);
/* We don't really care about errors here */
decode_ril_error(&error, "OK");
cb(&error, data);
}
static void ril_dial(struct ofono_voicecall *vc,
const struct ofono_phone_number *ph,
enum ofono_clir_option clir, ofono_voicecall_cb_t cb,
void *data)
{
struct voicecall_data *vd = ofono_voicecall_get_data(vc);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
int ret;
cbd->user = vc;
parcel_init(&rilp);
/* Number to dial */
parcel_w_string(&rilp, phone_number_to_string(ph));
/* CLIR mode */
parcel_w_int32(&rilp, clir);
/* USS, need it twice for absent */
/* TODO: Deal with USS properly */
parcel_w_int32(&rilp, 0);
parcel_w_int32(&rilp, 0);
/* Send request to RIL */
ret = g_ril_send(vd->ril, RIL_REQUEST_DIAL, rilp.data,
rilp.size, rild_cb, cbd, g_free);
parcel_free(&rilp);
/* 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_read_imsi(struct ofono_sim *sim, ofono_sim_imsi_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_GET_IMSI;
guint ret;
cbd->user = sd;
parcel_init(&rilp);
parcel_w_int32(&rilp, GET_IMSI_NUM_PARAMS);
parcel_w_string(&rilp, sd->aid_str);
ret = g_ril_send(sd->ril, request,
rilp.data, rilp.size, ril_imsi_cb, cbd, g_free);
g_ril_append_print_buf(sd->ril, "(%s)", 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, 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;
}
void g_ril_request_change_passwd(GRil *gril,
const char *old_passwd,
const char *new_passwd,
const gchar *aid_str,
struct parcel *rilp)
{
parcel_init(rilp);
parcel_w_int32(rilp, CHANGE_SIM_PIN_PARAMS);
parcel_w_string(rilp, old_passwd);
parcel_w_string(rilp, new_passwd);
parcel_w_string(rilp, aid_str);
g_ril_append_print_buf(gril, "(old=%s,new=%s,aid=%s)",
old_passwd, new_passwd, aid_str);
}
static void ril_stk_terminal_response(struct ofono_stk *stk, int length,
const unsigned char *resp,
ofono_stk_generic_cb_t cb, void *data)
{
struct stk_data *sd = ofono_stk_get_data(stk);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
char *hex_tr = NULL;
int request = RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE;
guint ret;
DBG("");
hex_tr = encode_hex(resp, length, 0);
DBG("rilmodem terminal response: %s", hex_tr);
parcel_init(&rilp);
parcel_w_string(&rilp, hex_tr);
g_free(hex_tr);
hex_tr = NULL;
ret = g_ril_send(sd->ril, request,
rilp.data, rilp.size, ril_tr_cb,
cbd, g_free);
parcel_free(&rilp);
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, data);
}
}
static void ril_stk_envelope(struct ofono_stk *stk, int length,
const unsigned char *command,
ofono_stk_envelope_cb_t cb, void *data)
{
struct stk_data *sd = ofono_stk_get_data(stk);
struct cb_data *cbd = cb_data_new(cb, data);
struct parcel rilp;
char *hex_envelope = NULL;
int request = RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND;
guint ret;
DBG("");
hex_envelope = encode_hex(command, length, 0);
DBG("rilmodem envelope: %s", hex_envelope);
parcel_init(&rilp);
parcel_w_string(&rilp, hex_envelope);
g_free(hex_envelope);
hex_envelope = NULL;
ret = g_ril_send(sd->ril, request,
rilp.data, rilp.size, ril_envelope_cb,
cbd, g_free);
parcel_free(&rilp);
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, NULL, -1, data);
}
}
static void ril_csca_set(struct ofono_sms *sms,
const struct ofono_phone_number *sca,
ofono_sms_sca_set_cb_t cb, void *user_data)
{
struct sms_data *data = ofono_sms_get_data(sms);
struct cb_data *cbd = cb_data_new(cb, user_data);
struct parcel rilp;
int ret = -1;
char number[OFONO_MAX_PHONE_NUMBER_LENGTH + 4];
if (sca->type == 129)
snprintf(number, sizeof(number), "\"%s\"", sca->number);
else
snprintf(number, sizeof(number), "\"+%s\"", sca->number);
DBG("Setting sca: %s", number);
parcel_init(&rilp);
parcel_w_string(&rilp, number);
/* Send request to RIL */
ret = g_ril_send(data->ril, RIL_REQUEST_SET_SMSC_ADDRESS, rilp.data,
rilp.size, ril_csca_set_cb, cbd, g_free);
parcel_free(&rilp);
/* In case of error free cbd and return the cb with failure */
if (ret <= 0) {
g_free(cbd);
CALLBACK_WITH_FAILURE(cb, user_data);
}
}
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;
}
