void ril_request_setup_data_call(RIL_Token t, void *data, int length)
{
struct ril_gprs_connection *gprs_connection = NULL;
struct ipc_client_gprs_capabilities gprs_capabilities;
struct ipc_gprs_port_list port_list;
struct ipc_client *ipc_client;
char *username = NULL;
char *password = NULL;
char *apn = NULL;
ipc_client = ((struct ipc_client_object *) ipc_fmt_client->object)->ipc_client;
apn = ((char **) data)[2];
username = ((char **) data)[3];
password = ((char **) data)[4];
LOGD("Requesting data connection to APN '%s'\n", apn);
gprs_connection = ril_gprs_connection_add();
if(!gprs_connection) {
LOGE("Unable to create GPRS connection, aborting");
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
return;
}
gprs_connection->token = t;
// Create the structs with the apn
ipc_gprs_define_pdp_context_setup(&(gprs_connection->define_context),
gprs_connection->cid, 1, apn);
// Create the structs with the username/password tuple
ipc_gprs_pdp_context_setup(&(gprs_connection->context),
gprs_connection->cid, 1, username, password);
ipc_client_gprs_get_capabilities(ipc_client, &gprs_capabilities);
// If the device has the capability, deal with port list
if(gprs_capabilities.port_list) {
ipc_gprs_port_list_setup(&port_list);
ipc_gen_phone_res_expect_to_func(reqGetId(t), IPC_GPRS_PORT_LIST,
ipc_gprs_port_list_complete);
ipc_fmt_send(IPC_GPRS_PORT_LIST, IPC_TYPE_SET,
(void *) &port_list, sizeof(struct ipc_gprs_port_list), reqGetId(t));
} else {
ipc_gen_phone_res_expect_to_func(reqGetId(t), IPC_GPRS_DEFINE_PDP_CONTEXT,
ipc_gprs_define_pdp_context_complete);
ipc_fmt_send(IPC_GPRS_DEFINE_PDP_CONTEXT, IPC_TYPE_SET,
(void *) &(gprs_connection->define_context),
sizeof(struct ipc_gprs_define_pdp_context), reqGetId(t));
}
}
void ril_request_deactivate_data_call(RIL_Token t, void *data, int length)
{
struct ril_gprs_connection *gprs_connection;
struct ipc_gprs_pdp_context_set context;
char *cid = ((char **) data)[0];
int rc;
gprs_connection = ril_gprs_connection_get_cid(atoi(cid));
if(!gprs_connection) {
LOGE("Unable to find GPRS connection, aborting");
RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
return;
}
gprs_connection->token = t;
ipc_gprs_pdp_context_setup(&context, gprs_connection->cid, 0, NULL, NULL);
ipc_gen_phone_res_expect_to_func(reqGetId(t), IPC_GPRS_PDP_CONTEXT,
ipc_gprs_pdp_context_disable_complete);
ipc_fmt_send(IPC_GPRS_PDP_CONTEXT, IPC_TYPE_SET,
(void *) &context, sizeof(struct ipc_gprs_pdp_context_set), reqGetId(t));
}
void ril_request_setup_data_call(RIL_Token t, void *data, int length)
{
char *username = NULL;
char *password = NULL;
char *apn = NULL;
struct ipc_gprs_define_pdp_context setup_apn_message;
struct ipc_gprs_pdp_context activate_message;
/* get the apn, username and password */
apn = ((char **) data)[2];
username = ((char **) data)[3];
if(username != NULL) {
if(strlen(username) < 2)
username = "******";
} else {
username = "******";
}
password = ((char **) data)[4];
if(password != NULL) {
if(strlen(password) < 2)
password = "******";
} else {
password = "******";
}
LOGD("Requesting data connection to APN '%s'\n", apn);
/* create the structs with the apn */
ipc_gprs_define_pdp_context_setup(&setup_apn_message, apn);
/* create the structs with the username/password tuple */
ipc_gprs_pdp_context_setup(&(ril_state.gprs_context), username, password);
/* send the struct to the modem */
ipc_send(IPC_GPRS_DEFINE_PDP_CONTEXT, IPC_TYPE_SET,
(void *) &setup_apn_message, sizeof(struct ipc_gprs_define_pdp_context), reqGetId(t));
ipc_gen_phone_res_expect_to_func(reqGetId(t), IPC_GPRS_DEFINE_PDP_CONTEXT,
ipc_gprs_pdp_context_complete);
}
void ipc_gprs_port_list_complete(struct ipc_message_info *info)
{
struct ipc_gen_phone_res *phone_res = (struct ipc_gen_phone_res *) info->data;
struct ril_gprs_connection *gprs_connection;
int rc;
int aseq;
gprs_connection = ril_gprs_connection_get_token(reqGetToken(info->aseq));
if(!gprs_connection) {
LOGE("Unable to find GPRS connection, aborting");
RIL_onRequestComplete(reqGetToken(info->aseq),
RIL_E_GENERIC_FAILURE, NULL, 0);
return;
}
rc = ipc_gen_phone_res_check(phone_res);
if(rc < 0) {
LOGE("There was an error, aborting port list complete");
gprs_connection->fail_cause = PDP_FAIL_ERROR_UNSPECIFIED;
gprs_connection->token = (RIL_Token) 0x00;
ril_state.gprs_last_failed_cid = gprs_connection->cid;
RIL_onRequestComplete(reqGetToken(info->aseq),
RIL_E_GENERIC_FAILURE, NULL, 0);
return;
}
// We need to get a clean new aseq here
aseq = ril_request_reg_id(reqGetToken(info->aseq));
ipc_gen_phone_res_expect_to_func(aseq, IPC_GPRS_DEFINE_PDP_CONTEXT,
ipc_gprs_define_pdp_context_complete);
ipc_fmt_send(IPC_GPRS_DEFINE_PDP_CONTEXT, IPC_TYPE_SET,
(void *) &(gprs_connection->define_context),
sizeof(struct ipc_gprs_define_pdp_context),
aseq);
}
void ril_request_send_sms_complete(RIL_Token t, char *pdu, int pdu_length, unsigned char *smsc, int smsc_length)
{
struct ipc_sms_send_msg_request send_msg;
unsigned char send_msg_type;
unsigned char *pdu_hex;
int pdu_hex_length;
void *data;
int length;
unsigned char *p;
if (pdu == NULL || pdu_length <= 0 || smsc == NULL || smsc_length <= 0)
goto error;
if ((pdu_length / 2 + smsc_length) > 0xfe) {
RIL_LOGE("PDU or SMSC too large, aborting");
goto error;
}
pdu_hex_length = pdu_length % 2 == 0 ? pdu_length / 2 :
(pdu_length ^ 1) / 2;
// Length of the final message
length = sizeof(send_msg) + pdu_hex_length + smsc_length;
RIL_LOGD("Sending SMS message (length: 0x%x)!", length);
pdu_hex = calloc(1, pdu_hex_length);
hex2bin(pdu, pdu_length, pdu_hex);
send_msg_type = IPC_SMS_MSG_SINGLE;
/* PDU operations */
int pdu_tp_da_index = 2;
unsigned char pdu_tp_da_len = pdu_hex[pdu_tp_da_index];
if (pdu_tp_da_len > 0xff / 2) {
RIL_LOGE("PDU TP-DA Len failed (0x%x)\n", pdu_tp_da_len);
goto pdu_end;
}
RIL_LOGD("PDU TP-DA Len is 0x%x\n", pdu_tp_da_len);
int pdu_tp_udh_index = pdu_tp_da_index + pdu_tp_da_len;
unsigned char pdu_tp_udh_len = pdu_hex[pdu_tp_udh_index];
if (pdu_tp_udh_len > 0xff / 2 || pdu_tp_udh_len < 5) {
RIL_LOGE("PDU TP-UDH Len failed (0x%x)\n", pdu_tp_udh_len);
goto pdu_end;
}
RIL_LOGD("PDU TP-UDH Len is 0x%x\n", pdu_tp_udh_len);
int pdu_tp_udh_num_index = pdu_tp_udh_index + 4;
unsigned char pdu_tp_udh_num = pdu_hex[pdu_tp_udh_num_index];
if (pdu_tp_udh_num > 0xf) {
RIL_LOGE("PDU TP-UDH Num failed (0x%x)\n", pdu_tp_udh_num);
goto pdu_end;
}
int pdu_tp_udh_seq_index = pdu_tp_udh_index + 5;
unsigned char pdu_tp_udh_seq = pdu_hex[pdu_tp_udh_seq_index];
if (pdu_tp_udh_seq > 0xf || pdu_tp_udh_seq > pdu_tp_udh_num) {
RIL_LOGE("PDU TP-UDH Seq failed (0x%x)\n", pdu_tp_udh_seq);
goto pdu_end;
}
RIL_LOGD("We are sending message %d on %d\n", pdu_tp_udh_seq, pdu_tp_udh_num);
if (pdu_tp_udh_num > 1) {
RIL_LOGD("We are sending a multi-part message!");
send_msg_type = IPC_SMS_MSG_MULTIPLE;
}
pdu_end:
// Alloc memory for the final message
data = calloc(1, length);
// Clear and fill the IPC structure part of the message
memset(&send_msg, 0, sizeof(struct ipc_sms_send_msg_request));
send_msg.type = IPC_SMS_TYPE_OUTGOING;
send_msg.msg_type = send_msg_type;
send_msg.length = (unsigned char) (pdu_hex_length + smsc_length + 1);
send_msg.smsc_len = smsc_length;
// Copy the parts of the message
p = data;
memcpy(p, &send_msg, sizeof(send_msg));
p += sizeof(send_msg);
memcpy(p, smsc, smsc_length);
p += smsc_length;
memcpy(p, pdu_hex, pdu_hex_length);
ipc_gen_phone_res_expect_to_func(ril_request_get_id(t), IPC_SMS_SEND_MSG, ipc_sms_send_msg_complete);
ipc_fmt_send(IPC_SMS_SEND_MSG, IPC_TYPE_EXEC, data, length, ril_request_get_id(t));
free(pdu_hex);
free(data);
return;
error:
ril_request_complete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
// Send the next SMS in the list
ril_request_send_sms_next();
}
