jenna
/
hardware_samsung
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ril: Align to AOSP libril

Browse Source 
* Adjusted whitespace to minimize diffs
 * Plugged memory leaks
 * Fix use-after-free
 * Use calloc instead of alloca
 * Reworked the Samsung request/response code to be
   more readable

Change-Id: Ifd07b525fc84e8a3fca584d4d412785974ca3482
tirimbino
Christopher N. Hesse 8 years ago
parent 928ddca2ec
commit 650848675d
6 changed files with 345 additions and 109 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      ril/include/libril/ril_ex.h
  2. 12
      ril/libril/Android.mk
  3. 28
      ril/libril/RilSapSocket.cpp
  4. 405
      ril/libril/ril.cpp
  5. 6
      ril/libril/ril_commands.h
  6. 1
      ril/libril/ril_unsol_commands.h

2
ril/include/libril/ril_ex.h
Unescape View File

@ -37,7 +37,7 @@ typedef struct SocketListenParam {
RIL_SOCKET_ID socket_id;
int fdListen;
int fdCommand;
char* processName;
const char* processName;
struct ril_event* commands_event;
struct ril_event* listen_event;
void (*processCommandsCallback)(int fd, short flags, void *param);

12
ril/libril/Android.mk
Unescape View File

@ -22,6 +22,10 @@ LOCAL_SHARED_LIBRARIES := \
LOCAL_STATIC_LIBRARIES := \
libprotobuf-c-nano-enable_malloc \
ifeq ($(SIM_COUNT), 2)
LOCAL_CFLAGS += -DANDROID_SIM_COUNT_2
endif
ifneq ($(filter xmm6262 xmm6360,$(BOARD_MODEM_TYPE)),)
LOCAL_CFLAGS := -DMODEM_TYPE_XMM6262
endif
@ -42,10 +46,12 @@ LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include
LOCAL_MODULE:= libril
LOCAL_CLANG := true
LOCAL_SANITIZE := integer
include $(BUILD_SHARED_LIBRARY)
# For RdoServD which needs a static library
# =========================================
ifneq ($(ANDROID_BIONIC_TRANSITION),)
@ -60,11 +66,13 @@ LOCAL_STATIC_LIBRARIES := \
librilutils_static \
libprotobuf-c-nano-enable_malloc
LOCAL_CFLAGS :=
ifneq ($(filter xmm6262 xmm6360,$(BOARD_MODEM_TYPE)),)
LOCAL_CFLAGS := -DMODEM_TYPE_XMM6262
LOCAL_CFLAGS += -DMODEM_TYPE_XMM6262
endif
ifeq ($(BOARD_MODEM_TYPE),xmm6260)
LOCAL_CFLAGS := -DMODEM_TYPE_XMM6260
LOCAL_CFLAGS += -DMODEM_TYPE_XMM6260
endif
LOCAL_MODULE:= libril_static

28
ril/libril/RilSapSocket.cpp
Unescape View File

@ -21,6 +21,7 @@
#include "RilSapSocket.h"
#include "pb_decode.h"
#include "pb_encode.h"
#undef LOG_TAG
#define LOG_TAG "RIL_UIM_SOCKET"
#include <utils/Log.h>
#include <arpa/inet.h>
@ -344,15 +345,20 @@ void RilSapSocket::sendResponse(MsgHeader* hdr) {
if ((success = pb_get_encoded_size(&encoded_size, MsgHeader_fields,
hdr)) && encoded_size <= INT32_MAX && commandFd != -1) {
buffer_size = encoded_size + sizeof(uint32_t);
uint8_t buffer[buffer_size];
uint8_t* buffer = (uint8_t*)malloc(buffer_size);
if (!buffer) {
RLOGE("sendResponse: OOM");
pthread_mutex_unlock(&write_lock);
return;
}
written_size = htonl((uint32_t) encoded_size);
ostream = pb_ostream_from_buffer(buffer, buffer_size);
pb_write(&ostream, (uint8_t *)&written_size, sizeof(written_size));
success = pb_encode(&ostream, MsgHeader_fields, hdr);
if (success) {
RLOGD("Size: %d (0x%x) Size as written: 0x%x", encoded_size, encoded_size,
written_size);
RLOGD("Size: %zu (0x%zx) Size as written: 0x%x", encoded_size,
encoded_size, written_size);
log_hex("onRequestComplete", &buffer[sizeof(written_size)], encoded_size);
RLOGI("[%d] < SAP RESPONSE type: %d. id: %d. error: %d",
hdr->token, hdr->type, hdr->id,hdr->error );
@ -363,12 +369,13 @@ void RilSapSocket::sendResponse(MsgHeader* hdr) {
RLOGD("Write successful");
}
} else {
RLOGE("Error while encoding response of type %d id %d buffer_size: %d: %s.",
hdr->type, hdr->id, buffer_size, PB_GET_ERROR(&ostream));
RLOGE("Error while encoding response of type %d id %d buffer_size: %zu: %s.",
hdr->type, hdr->id, buffer_size, PB_GET_ERROR(&ostream));
}
free(buffer);
} else {
RLOGE("Not sending response type %d: encoded_size: %u. commandFd: %d. encoded size result: %d",
hdr->type, encoded_size, commandFd, success);
RLOGE("Not sending response type %d: encoded_size: %zu. commandFd: %d. encoded size result:\
%d", hdr->type, encoded_size, commandFd, success);
}
pthread_mutex_unlock(&write_lock);
@ -437,7 +444,11 @@ void RilSapSocket::sendDisconnect() {
if ((success = pb_get_encoded_size(&encoded_size, RIL_SIM_SAP_DISCONNECT_REQ_fields,
&disconnectReq)) && encoded_size <= INT32_MAX) {
buffer_size = encoded_size + sizeof(uint32_t);
uint8_t buffer[buffer_size];
uint8_t* buffer = (uint8_t*)malloc(buffer_size);
if (!buffer) {
RLOGE("sendDisconnect: OOM");
return;
}
written_size = htonl((uint32_t) encoded_size);
ostream = pb_ostream_from_buffer(buffer, buffer_size);
pb_write(&ostream, (uint8_t *)&written_size, sizeof(written_size));
@ -469,6 +480,7 @@ void RilSapSocket::sendDisconnect() {
else {
RLOGE("Encode failed in send disconnect!");
}
free(buffer);
}
}

405
ril/libril/ril.cpp
Unescape View File

@ -42,7 +42,6 @@
#include <errno.h>
#include <assert.h>
#include <ctype.h>
#include <alloca.h>
#include <sys/un.h>
#include <assert.h>
#include <netinet/in.h>
@ -108,8 +107,8 @@ namespace android {
#if RILC_LOG
#define startRequest sprintf(printBuf, "(")
#define closeRequest sprintf(printBuf, "%s)", printBuf)
#define printRequest(token, req) \
RLOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
#define printRequest(token, req) \
RLOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
#define startResponse sprintf(printBuf, "%s {", printBuf)
#define closeResponse sprintf(printBuf, "%s}", printBuf)
@ -286,8 +285,9 @@ static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI);
static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI);
static void dispatchDataProfile(Parcel &p, RequestInfo *pRI);
static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI);
static void dispatchCarrierRestrictions(Parcel &p, RequestInfo *pRI);
static int responseInts(Parcel &p, void *response, size_t responselen);
static int responseIntsGetPreferredNetworkType(Parcel &p, void *response, size_t responselen);
static int responseFailCause(Parcel &p, void *response, size_t responselen);
static int responseStrings(Parcel &p, void *response, size_t responselen);
static int responseString(Parcel &p, void *response, size_t responselen);
static int responseVoid(Parcel &p, void *response, size_t responselen);
@ -319,6 +319,8 @@ static int responseLceStatus(Parcel &p, void *response, size_t responselen);
static int responseLceData(Parcel &p, void *response, size_t responselen);
static int responseActivityData(Parcel &p, void *response, size_t responselen);
static int responseCarrierRestrictions(Parcel &p, void *response, size_t responselen);
static int responsePcoData(Parcel &p, void *response, size_t responselen);
static int decodeVoiceRadioTechnology (RIL_RadioState radioState);
static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
static RIL_RadioState processRadioState(RIL_RadioState newRadioState);
@ -483,13 +485,13 @@ issueLocalRequest(int request, void *data, int len, RIL_SOCKET_ID socket_id) {
pRI->local = 1;
pRI->token = 0xffffffff; // token is not used in this context
/* Check vendor commands */
pRI->pCI = &(s_commands[request]);
pRI->socket_id = socket_id;
/* Hack to include Samsung requests */
if (request > RIL_VENDOR_COMMANDS_OFFSET) {
pRI->pCI = &(s_commands_v[request - RIL_VENDOR_COMMANDS_OFFSET]);
} else {
pRI->pCI = &(s_commands[request]);
}
pRI->socket_id = socket_id;
ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
@ -582,7 +584,7 @@ processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) {
return 0;
}
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
if (pRI == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(request));
return 0;
@ -668,7 +670,7 @@ dispatchStrings (Parcel &p, RequestInfo *pRI) {
startRequest;
if (countStrings == 0) {
// just some non-null pointer
pStrings = (char **)alloca(sizeof(char *));
pStrings = (char **)calloc(1, sizeof(char *));
if (pStrings == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
@ -677,13 +679,13 @@ dispatchStrings (Parcel &p, RequestInfo *pRI) {
}
datalen = 0;
} else if (((int)countStrings) == -1) {
} else if (countStrings < 0) {
pStrings = NULL;
datalen = 0;
} else {
datalen = sizeof(char *) * countStrings;
pStrings = (char **)alloca(datalen);
pStrings = (char **)calloc(countStrings, sizeof(char *));
if (pStrings == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
@ -713,6 +715,7 @@ dispatchStrings (Parcel &p, RequestInfo *pRI) {
#ifdef MEMSET_FREED
memset(pStrings, 0, datalen);
#endif
free(pStrings);
}
return;
@ -731,12 +734,12 @@ dispatchInts (Parcel &p, RequestInfo *pRI) {
status = p.readInt32 (&count);
if (status != NO_ERROR || count == 0) {
if (status != NO_ERROR || count <= 0) {
goto invalid;
}
datalen = sizeof(int) * count;
pInts = (int *)alloca(datalen);
pInts = (int *)calloc(count, sizeof(int));
if (pInts == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
return;
@ -751,6 +754,7 @@ dispatchInts (Parcel &p, RequestInfo *pRI) {
appendPrintBuf("%s%d,", printBuf, t);
if (status != NO_ERROR) {
free(pInts);
goto invalid;
}
}
@ -764,7 +768,7 @@ dispatchInts (Parcel &p, RequestInfo *pRI) {
#ifdef MEMSET_FREED
memset(pInts, 0, datalen);
#endif
free(pInts);
return;
invalid:
invalidCommandBlock(pRI);
@ -1376,7 +1380,7 @@ dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef
(int)rism.tech, (int)rism.retry, rism.messageRef);
if (countStrings == 0) {
// just some non-null pointer
pStrings = (char **)alloca(sizeof(char *));
pStrings = (char **)calloc(1, sizeof(char *));
if (pStrings == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
@ -1385,13 +1389,18 @@ dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef
}
datalen = 0;
} else if (((int)countStrings) == -1) {
} else if (countStrings < 0) {
pStrings = NULL;
datalen = 0;
} else {
if ((size_t)countStrings > (INT_MAX/sizeof(char *))) {
RLOGE("Invalid value of countStrings: \n");
closeRequest;
return;
}
datalen = sizeof(char *) * countStrings;
pStrings = (char **)alloca(datalen);
pStrings = (char **)calloc(countStrings, sizeof(char *));
if (pStrings == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
@ -1424,6 +1433,7 @@ dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef
#ifdef MEMSET_FREED
memset(pStrings, 0, datalen);
#endif
free(pStrings);
}
#ifdef MEMSET_FREED
@ -1431,7 +1441,7 @@ dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef
#endif
return;
invalid:
RLOGE("dispatchImsGsmSms invalid block");
ALOGE("dispatchImsGsmSms invalid block");
invalidCommandBlock(pRI);
return;
}
@ -1466,7 +1476,7 @@ dispatchImsSms(Parcel &p, RequestInfo *pRI) {
} else if (RADIO_TECH_3GPP2 == format) {
dispatchImsCdmaSms(p, pRI, retry, messageRef);
} else {
RLOGE("requestImsSendSMS invalid format value =%d", format);
ALOGE("requestImsSendSMS invalid format value =%d", format);
}
return;
@ -1838,7 +1848,7 @@ static void dispatchSetInitialAttachApn(Parcel &p, RequestInfo *pRI)
pf.password = strdupReadString(p);
startRequest;
appendPrintBuf("%sapn=%s, protocol=%s, auth_type=%d, username=%s, password=%s",
appendPrintBuf("%sapn=%s, protocol=%s, authtype=%d, username=%s, password=%s",
printBuf, pf.apn, pf.protocol, pf.authtype, pf.username, pf.password);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
@ -2010,7 +2020,7 @@ static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI)
pf.aid = strdupReadString(p);
startRequest;
appendPrintBuf("authContext=%d, authData=%s, aid=%s", pf.authContext, pf.authData, pf.aid);
appendPrintBuf("authContext=%s, authData=%s, aid=%s", pf.authContext, pf.authData, pf.aid);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
@ -2043,20 +2053,20 @@ static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) {
int32_t num;
status = p.readInt32(&num);
if (status != NO_ERROR) {
if (status != NO_ERROR || num < 0) {
goto invalid;
}
{
RIL_DataProfileInfo *dataProfiles =
(RIL_DataProfileInfo *)malloc(num * sizeof(RIL_DataProfileInfo));
(RIL_DataProfileInfo *)calloc(num, sizeof(RIL_DataProfileInfo));
if (dataProfiles == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
return;
}
RIL_DataProfileInfo **dataProfilePtrs =
(RIL_DataProfileInfo **)malloc(num * sizeof(RIL_DataProfileInfo *));
(RIL_DataProfileInfo **)calloc(num, sizeof(RIL_DataProfileInfo *));
if (dataProfilePtrs == NULL) {
RLOGE("Memory allocation failed for request %s",
requestToString(pRI->pCI->requestNumber));
@ -2174,7 +2184,7 @@ static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI){
startRequest;
appendPrintBuf("%s [version:%d, session:%d, phase:%d, rat:%d, \
logicalModemUuid:%s, status:%d", printBuf, rc.version, rc.session,
rc.phase, rc.rat, rc.logicalModemUuid, rc.status);
rc.phase, rc.rat, rc.logicalModemUuid, rc.session);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
@ -2189,6 +2199,105 @@ invalid:
return;
}
/**
* Callee expects const RIL_CarrierRestrictions *
*/
static void dispatchCarrierRestrictions(Parcel &p, RequestInfo *pRI) {
RIL_CarrierRestrictions cr;
RIL_Carrier * allowed_carriers = NULL;
RIL_Carrier * excluded_carriers = NULL;
int32_t t;
status_t status;
memset(&cr, 0, sizeof(RIL_CarrierRestrictions));
if (s_callbacks.version < 14) {
RLOGE("Unsuppoted RIL version %d, min version expected %d",
s_callbacks.version, 14);
RIL_onRequestComplete(pRI, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
return;
}
status = p.readInt32(&t);
if (status != NO_ERROR) {
goto invalid;
}
allowed_carriers = (RIL_Carrier *)calloc(t, sizeof(RIL_Carrier));
if (allowed_carriers == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
goto exit;
}
cr.len_allowed_carriers = t;
cr.allowed_carriers = allowed_carriers;
status = p.readInt32(&t);
if (status != NO_ERROR) {
goto invalid;
}
excluded_carriers = (RIL_Carrier *)calloc(t, sizeof(RIL_Carrier));
if (excluded_carriers == NULL) {
RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
goto exit;
}
cr.len_excluded_carriers = t;
cr.excluded_carriers = excluded_carriers;
startRequest;
appendPrintBuf("%s len_allowed_carriers:%d, len_excluded_carriers:%d,",
printBuf, cr.len_allowed_carriers, cr.len_excluded_carriers);
appendPrintBuf("%s allowed_carriers:", printBuf);
for (int32_t i = 0; i < cr.len_allowed_carriers; i++) {
RIL_Carrier *p_cr = allowed_carriers + i;
p_cr->mcc = strdupReadString(p);
p_cr->mnc = strdupReadString(p);
status = p.readInt32(&t);
p_cr->match_type = static_cast<RIL_CarrierMatchType>(t);
if (status != NO_ERROR) {
goto invalid;
}
p_cr->match_data = strdupReadString(p);
appendPrintBuf("%s [%d mcc:%s, mnc:%s, match_type:%d, match_data:%s],",
printBuf, i, p_cr->mcc, p_cr->mnc, p_cr->match_type, p_cr->match_data);
}
for (int32_t i = 0; i < cr.len_excluded_carriers; i++) {
RIL_Carrier *p_cr = excluded_carriers + i;
p_cr->mcc = strdupReadString(p);
p_cr->mnc = strdupReadString(p);
status = p.readInt32(&t);
p_cr->match_type = static_cast<RIL_CarrierMatchType>(t);
if (status != NO_ERROR) {
goto invalid;
}
p_cr->match_data = strdupReadString(p);
appendPrintBuf("%s [%d mcc:%s, mnc:%s, match_type:%d, match_data:%s],",
printBuf, i, p_cr->mcc, p_cr->mnc, p_cr->match_type, p_cr->match_data);
}
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
CALL_ONREQUEST(pRI->pCI->requestNumber,
&cr,
sizeof(RIL_CarrierRestrictions),
pRI, pRI->socket_id);
goto exit;
invalid:
invalidCommandBlock(pRI);
RIL_onRequestComplete(pRI, RIL_E_INVALID_ARGUMENTS, NULL, 0);
exit:
if (allowed_carriers != NULL) {
free(allowed_carriers);
}
if (excluded_carriers != NULL) {
free(excluded_carriers);
}
return;
}
static int
blockingWrite(int fd, const void *buffer, size_t len) {
size_t writeOffset = 0;
@ -2225,7 +2334,7 @@ sendResponseRaw (const void *data, size_t dataSize, RIL_SOCKET_ID socket_id) {
pthread_mutex_t * writeMutexHook = &s_writeMutex;
#if VDBG
RLOGD("Send Response to %s", rilSocketIdToString(socket_id));
RLOGE("Send Response to %s", rilSocketIdToString(socket_id));
#endif
#if (SIM_COUNT >= 2)
@ -2319,37 +2428,37 @@ responseInts(Parcel &p, void *response, size_t responselen) {
return 0;
}
static int
responseIntsGetPreferredNetworkType(Parcel &p, void *response, size_t responselen) {
// Response is an int or RIL_LastCallFailCauseInfo.
// Currently, only Shamu plans to use RIL_LastCallFailCauseInfo.
// TODO(yjl): Let all implementations use RIL_LastCallFailCauseInfo.
static int responseFailCause(Parcel &p, void *response, size_t responselen) {
int numInts;
if (response == NULL && responselen != 0) {
RLOGE("invalid response: NULL");
return RIL_ERRNO_INVALID_RESPONSE;
}
if (responselen % sizeof(int) != 0) {
RLOGE("responseInts: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof(int));
return RIL_ERRNO_INVALID_RESPONSE;
}
int *p_int = (int *) response;
numInts = responselen / sizeof(int);
p.writeInt32 (numInts);
/* each int*/
startResponse;
for (int i = 0 ; i < numInts ; i++) {
if (i == 0 && p_int[0] == 7) {
RLOGD("REQUEST_GET_PREFERRED_NETWORK_TYPE: NETWORK_MODE_GLOBAL => NETWORK_MODE_WCDMA_PREF");
p_int[0] = 0;
}
appendPrintBuf("%s%d,", printBuf, p_int[i]);
p.writeInt32(p_int[i]);
if (responselen == sizeof(int)) {
startResponse;
int *p_int = (int *) response;
appendPrintBuf("%s%d,", printBuf, p_int[0]);
p.writeInt32(p_int[0]);
removeLastChar;
closeResponse;
} else if (responselen == sizeof(RIL_LastCallFailCauseInfo)) {
startResponse;
RIL_LastCallFailCauseInfo *p_fail_cause_info = (RIL_LastCallFailCauseInfo *) response;
appendPrintBuf("%s[cause_code=%d,vendor_cause=%s]", printBuf, p_fail_cause_info->cause_code,
p_fail_cause_info->vendor_cause);
p.writeInt32(p_fail_cause_info->cause_code);
writeStringToParcel(p, p_fail_cause_info->vendor_cause);
removeLastChar;
closeResponse;
} else {
RLOGE("responseFailCause: invalid response length %d expected an int or "
"RIL_LastCallFailCauseInfo", (int)responselen);
return RIL_ERRNO_INVALID_RESPONSE;
}
removeLastChar;
closeResponse;
return 0;
}
@ -2601,7 +2710,7 @@ static int responseDataCallListV6(Parcel &p, void *response, size_t responselen)
writeStringToParcel(p, p_cur[i].ifname);
writeStringToParcel(p, p_cur[i].addresses);
writeStringToParcel(p, p_cur[i].dnses);
writeStringToParcel(p, p_cur[i].addresses);
writeStringToParcel(p, p_cur[i].gateways);
appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf,
p_cur[i].status,
p_cur[i].suggestedRetryTime,
@ -2611,7 +2720,7 @@ static int responseDataCallListV6(Parcel &p, void *response, size_t responselen)
(char*)p_cur[i].ifname,
(char*)p_cur[i].addresses,
(char*)p_cur[i].dnses,
(char*)p_cur[i].addresses);
(char*)p_cur[i].gateways);
}
removeLastChar;
closeResponse;
@ -2954,8 +3063,7 @@ static int responseCdmaInformationRecords(Parcel &p,
CDMA_ALPHA_INFO_BUFFER_LENGTH);
return RIL_ERRNO_INVALID_RESPONSE;
}
string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
* sizeof(char) );
string8 = (char*) calloc(infoRec->rec.display.alpha_len + 1, sizeof(char));
if (string8 == NULL) {
RLOGE("Memory allocation failed for responseCdmaInformationRecords");
closeRequest;
@ -2979,8 +3087,7 @@ static int responseCdmaInformationRecords(Parcel &p,
CDMA_NUMBER_INFO_BUFFER_LENGTH);
return RIL_ERRNO_INVALID_RESPONSE;
}
string8 = (char*) malloc((infoRec->rec.number.len + 1)
* sizeof(char) );
string8 = (char*) calloc(infoRec->rec.number.len + 1, sizeof(char));
if (string8 == NULL) {
RLOGE("Memory allocation failed for responseCdmaInformationRecords");
closeRequest;
@ -3021,8 +3128,8 @@ static int responseCdmaInformationRecords(Parcel &p,
CDMA_NUMBER_INFO_BUFFER_LENGTH);
return RIL_ERRNO_INVALID_RESPONSE;
}
string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
.len + 1) * sizeof(char) );
string8 = (char*) calloc(infoRec->rec.redir.redirectingNumber.len + 1,
sizeof(char));
if (string8 == NULL) {
RLOGE("Memory allocation failed for responseCdmaInformationRecords");
closeRequest;
@ -3106,9 +3213,6 @@ static void responseRilSignalStrengthV5(Parcel &p, RIL_SignalStrength_v10 *p_cur
gsmSignalStrength = 31;
}
#endif
p.writeInt32(gsmSignalStrength);
p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
#if defined(MODEM_TYPE_XMM6262) || defined(SAMSUNG_NEXT_GEN_MODEM)
cdmaDbm = p_cur->CDMA_SignalStrength.dbm & 0xFF;
@ -3120,8 +3224,6 @@ static void responseRilSignalStrengthV5(Parcel &p, RIL_SignalStrength_v10 *p_cur
#else
cdmaDbm = p_cur->CDMA_SignalStrength.dbm;
#endif
p.writeInt32(cdmaDbm);
p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
#if defined(MODEM_TYPE_XMM6262) || defined(SAMSUNG_NEXT_GEN_MODEM)
evdoDbm = p_cur->EVDO_SignalStrength.dbm & 0xFF;
@ -3133,9 +3235,14 @@ static void responseRilSignalStrengthV5(Parcel &p, RIL_SignalStrength_v10 *p_cur
#else
evdoDbm = p_cur->EVDO_SignalStrength.dbm;
#endif
p.writeInt32(evdoDbm);
p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
p.writeInt32(gsmSignalStrength);
p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
p.writeInt32(cdmaDbm);
p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
p.writeInt32(evdoDbm);
p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
}
static void responseRilSignalStrengthV6Extra(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
@ -3177,7 +3284,6 @@ static void responseRilSignalStrengthV10(Parcel &p, RIL_SignalStrength_v10 *p_cu
p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp);
}
static int responseRilSignalStrength(Parcel &p,
void *response, size_t responselen) {
if (response == NULL && responselen != 0) {
@ -3223,7 +3329,6 @@ static int responseRilSignalStrength(Parcel &p,
p_cur = ((RIL_SignalStrength_v10 *) response);
responseRilSignalStrengthV10(p, p_cur);
}
startResponse;
appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
@ -3436,6 +3541,8 @@ static int responseCellInfoListV6(Parcel &p, void *response, size_t responselen)
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.cid);
p.writeInt32(INT_MAX); /* skip arfcn */
p.writeInt32(INT_MAX); /* skip bsic */
p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength);
p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
break;
@ -3456,6 +3563,7 @@ static int responseCellInfoListV6(Parcel &p, void *response, size_t responselen)
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.cid);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.psc);
p.writeInt32(INT_MAX); /* skip uarfcn */
p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength);
p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
break;
@ -3501,6 +3609,7 @@ static int responseCellInfoListV6(Parcel &p, void *response, size_t responselen)
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.ci);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.pci);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.tac);
p.writeInt32(INT_MAX); /* skip earfcn */
appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf,
p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
@ -3851,7 +3960,7 @@ static int responseRadioCapability(Parcel &p, void *response, size_t responselen
startResponse;
appendPrintBuf("%s[version=%d,session=%d,phase=%d,\
rat=%d,logicalModemUuid=%s,status=%d]",
rat=%s,logicalModemUuid=%s,status=%d]",
printBuf,
p_cur->version,
p_cur->session,
@ -4162,7 +4271,7 @@ static int responseDcRtInfo(Parcel &p, void *response, size_t responselen)
p.writeInt32(pDcRtInfo->powerState);
appendPrintBuf("%s[time=%d,powerState=%d]", printBuf,
pDcRtInfo->time,
(int)pDcRtInfo->powerState);
pDcRtInfo->powerState);
closeResponse;
return 0;
@ -4174,8 +4283,8 @@ static int responseLceStatus(Parcel &p, void *response, size_t responselen) {
RLOGE("invalid response: NULL");
}
else {
RLOGE("responseLceStatus: invalid response length %d expecting len: d%",
sizeof(RIL_LceStatusInfo), responselen);
RLOGE("responseLceStatus: invalid response length %u expecting len: %u",
(unsigned)sizeof(RIL_LceStatusInfo), (unsigned)responselen);
}
return RIL_ERRNO_INVALID_RESPONSE;
}
@ -4198,8 +4307,8 @@ static int responseLceData(Parcel &p, void *response, size_t responselen) {
RLOGE("invalid response: NULL");
}
else {
RLOGE("responseLceData: invalid response length %d expecting len: d%",
sizeof(RIL_LceDataInfo), responselen);
RLOGE("responseLceData: invalid response length %u expecting len: %u",
(unsigned)sizeof(RIL_LceDataInfo), (unsigned)responselen);
}
return RIL_ERRNO_INVALID_RESPONSE;
}
@ -4227,8 +4336,8 @@ static int responseActivityData(Parcel &p, void *response, size_t responselen) {
RLOGE("invalid response: NULL");
}
else {
RLOGE("responseActivityData: invalid response length %d expecting len: d%",
sizeof(RIL_ActivityStatsInfo), responselen);
RLOGE("responseActivityData: invalid response length %u expecting len: %u",
(unsigned)sizeof(RIL_ActivityStatsInfo), (unsigned)responselen);
}
return RIL_ERRNO_INVALID_RESPONSE;
}
@ -4252,6 +4361,78 @@ static int responseActivityData(Parcel &p, void *response, size_t responselen) {
return 0;
}
static int responseCarrierRestrictions(Parcel &p, void *response, size_t responselen) {
if (response == NULL) {
RLOGE("invalid response: NULL");
return RIL_ERRNO_INVALID_RESPONSE;
}
if (responselen != sizeof(RIL_CarrierRestrictions)) {
RLOGE("responseCarrierRestrictions: invalid response length %u expecting len: %u",
(unsigned)responselen, (unsigned)sizeof(RIL_CarrierRestrictions));
return RIL_ERRNO_INVALID_RESPONSE;
}
RIL_CarrierRestrictions *p_cr = (RIL_CarrierRestrictions *)response;
startResponse;
p.writeInt32(p_cr->len_allowed_carriers);
p.writeInt32(p_cr->len_excluded_carriers);
appendPrintBuf(" %s len_allowed_carriers: %d, len_excluded_carriers: %d,", printBuf,
p_cr->len_allowed_carriers,p_cr->len_excluded_carriers);
appendPrintBuf(" %s allowed_carriers:", printBuf);
for(int32_t i = 0; i < p_cr->len_allowed_carriers; i++) {
RIL_Carrier *carrier = p_cr->allowed_carriers + i;
writeStringToParcel(p, carrier->mcc);
writeStringToParcel(p, carrier->mnc);
p.writeInt32(carrier->match_type);
writeStringToParcel(p, carrier->match_data);
appendPrintBuf(" %s [%d mcc: %s, mnc: %s, match_type: %d, match_data: %s],", printBuf,
i, carrier->mcc, carrier->mnc, carrier->match_type, carrier->match_data);
}
appendPrintBuf(" %s excluded_carriers:", printBuf);
for(int32_t i = 0; i < p_cr->len_excluded_carriers; i++) {
RIL_Carrier *carrier = p_cr->excluded_carriers + i;
writeStringToParcel(p, carrier->mcc);
writeStringToParcel(p, carrier->mnc);
p.writeInt32(carrier->match_type);
writeStringToParcel(p, carrier->match_data);
appendPrintBuf(" %s [%d mcc: %s, mnc: %s, match_type: %d, match_data: %s],", printBuf,
i, carrier->mcc, carrier->mnc, carrier->match_type, carrier->match_data);
}
closeResponse;
return 0;
}
static int responsePcoData(Parcel &p, void *response, size_t responselen) {
if (response == NULL) {
RLOGE("responsePcoData: invalid NULL response");
return RIL_ERRNO_INVALID_RESPONSE;
}
if (responselen != sizeof(RIL_PCO_Data)) {
RLOGE("responsePcoData: invalid response length %u, expecting %u",
(unsigned)responselen, (unsigned)sizeof(RIL_PCO_Data));
return RIL_ERRNO_INVALID_RESPONSE;
}
RIL_PCO_Data *p_cur = (RIL_PCO_Data *)response;
p.writeInt32(p_cur->cid);
writeStringToParcel(p, p_cur->bearer_proto);
p.writeInt32(p_cur->pco_id);
p.writeInt32(p_cur->contents_length);
p.write(p_cur->contents, p_cur->contents_length);
startResponse;
appendPrintBuf("PCO data received: cid %d, id %d, length %d",
p_cur->cid, p_cur->pco_id, p_cur->contents_length);
closeResponse;
return 0;
}
/**
* A write on the wakeup fd is done just to pop us out of select()
* We empty the buffer here and then ril_event will reset the timers on the
@ -4398,7 +4579,7 @@ static void listenCallback (int fd, short flags, void *param) {
int err;
int is_phone_socket;
int fdCommand = -1;
char* processName;
const char* processName;
RecordStream *p_rs;
MySocketListenParam* listenParam;
RilSocket *sapSocket = NULL;
@ -4559,7 +4740,13 @@ static void debugCallback (int fd, short flags, void *param) {
return;
}
args = (char **) malloc(sizeof(char*) * number);
if (number < 0) {
RLOGE ("Invalid number of arguments: \n");
close(acceptFD);
return;
}
args = (char **) calloc(number, sizeof(char*));
if (args == NULL) {
RLOGE("Memory allocation failed for debug args");
close(acceptFD);
@ -4575,8 +4762,15 @@ static void debugCallback (int fd, short flags, void *param) {
return;
}
if (len == INT_MAX || len < 0) {
RLOGE("Invalid value of len: \n");
freeDebugCallbackArgs(i, args);
close(acceptFD);
return;
}
// +1 for null-term
args[i] = (char *) malloc((sizeof(char) * len) + 1);
args[i] = (char *) calloc(len + 1, sizeof(char));
if (args[i] == NULL) {
RLOGE("Memory allocation failed for debug args");
freeDebugCallbackArgs(i, args);
@ -4888,7 +5082,8 @@ RIL_register (const RIL_RadioFunctions *callbacks) {
&s_commands_event, /* commands_event */
&s_listen_event, /* listen_event */
processCommandsCallback, /* processCommandsCallback */
NULL /* p_rs */
NULL, /* p_rs */
RIL_TELEPHONY_SOCKET /* type */
};
#if (SIM_COUNT >= 2)
@ -4900,7 +5095,8 @@ RIL_register (const RIL_RadioFunctions *callbacks) {
&s_commands_event_socket2, /* commands_event */
&s_listen_event_socket2, /* listen_event */
processCommandsCallback, /* processCommandsCallback */
NULL /* p_rs */
NULL, /* p_rs */
RIL_TELEPHONY_SOCKET /* type */
};
#endif
@ -4913,7 +5109,8 @@ RIL_register (const RIL_RadioFunctions *callbacks) {
&s_commands_event_socket3, /* commands_event */
&s_listen_event_socket3, /* listen_event */
processCommandsCallback, /* processCommandsCallback */
NULL /* p_rs */
NULL, /* p_rs */
RIL_TELEPHONY_SOCKET /* type */
};
#endif
@ -4926,7 +5123,8 @@ RIL_register (const RIL_RadioFunctions *callbacks) {
&s_commands_event_socket4, /* commands_event */
&s_listen_event_socket4, /* listen_event */
processCommandsCallback, /* processCommandsCallback */
NULL /* p_rs */
NULL, /* p_rs */
RIL_TELEPHONY_SOCKET /* type */
};
#endif
@ -4990,7 +5188,7 @@ RIL_register (const RIL_RadioFunctions *callbacks) {
char rildebug[MAX_DEBUG_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL_DEBUG;
if (inst != NULL) {
snprintf(rildebug, sizeof(rildebug), "%s%s", SOCKET_NAME_RIL_DEBUG, inst);
strlcat(rildebug, inst, MAX_DEBUG_SOCKET_NAME_LENGTH);
}
s_fdDebug = android_get_control_socket(rildebug);
@ -5038,6 +5236,8 @@ RIL_register_socket (RIL_RadioFunctions *(*Init)(const struct RIL_Env *, int, ch
#if (SIM_COUNT >= 4)
RilSapSocket::initSapSocket("sap_uim_socket4", UimFuncs);
#endif
break;
default:;
}
}
}
@ -5434,12 +5634,14 @@ void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
size_t datalen)
#endif
{
int unsolResponseIndex;
int ret;
int64_t timeReceived = 0;
bool shouldScheduleTimeout = false;
RIL_RadioState newState;
RIL_SOCKET_ID soc_id = RIL_SOCKET_1;
UnsolResponseInfo *pRI = NULL;
int32_t pRI_elements;
#if defined(ANDROID_MULTI_SIM)
soc_id = socket_id;
@ -5452,18 +5654,25 @@ void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
return;
}
unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
pRI = s_unsolResponses;
/* Hack to include Samsung responses */
if (unsolResponse > RIL_VENDOR_COMMANDS_OFFSET + RIL_UNSOL_RESPONSE_BASE) {
int index = unsolResponse - RIL_VENDOR_COMMANDS_OFFSET - RIL_UNSOL_RESPONSE_BASE;
unsolResponseIndex -= RIL_VENDOR_COMMANDS_OFFSET;
pRI = s_unsolResponses_v;
RLOGD("SAMSUNG: unsolResponse=%d, unsolResponseIndex=%d", unsolResponse, index);
RLOGD("SAMSUNG: unsolResponse=%d, unsolResponseIndex=%d", unsolResponse, unsolResponseIndex);
}
pRI_elements = pRI == s_unsolResponses
? (int32_t)NUM_ELEMS(s_unsolResponses) : (int32_t)NUM_ELEMS(s_unsolResponses_v);
if (index < (int32_t)NUM_ELEMS(s_unsolResponses_v))
pRI = &s_unsolResponses_v[index];
if (unsolResponseIndex >= 0 && unsolResponseIndex < pRI_elements) {
pRI = &pRI[unsolResponseIndex];
} else {
int index = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
if (index < (int32_t)NUM_ELEMS(s_unsolResponses))
pRI = &s_unsolResponses[index];
RLOGE("unsolResponseIndex out of bounds: %d, using %s response array", unsolResponseIndex,
pRI == s_unsolResponses ? "AOSP" : "Samsung");
}
if (pRI == NULL || pRI->responseFunction == NULL) {
@ -5566,7 +5775,7 @@ void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
s_lastNITZTimeData = NULL;
}
s_lastNITZTimeData = malloc(p.dataSize());
s_lastNITZTimeData = calloc(p.dataSize(), 1);
if (s_lastNITZTimeData == NULL) {
RLOGE("Memory allocation failed in RIL_onUnsolicitedResponse");
goto error_exit;
@ -5594,7 +5803,7 @@ internalRequestTimedCallback (RIL_TimedCallback callback, void *param,
struct timeval myRelativeTime;
UserCallbackInfo *p_info;
p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
p_info = (UserCallbackInfo *) calloc(1, sizeof(UserCallbackInfo));
if (p_info == NULL) {
RLOGE("Memory allocation failed in internalRequestTimedCallback");
return p_info;
@ -5824,6 +6033,7 @@ requestToString(int request) {
case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
case RIL_REQUEST_NV_RESET_CONFIG: return "NV_RESET_CONFIG";
case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
@ -5887,6 +6097,8 @@ requestToString(int request) {
case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
case RIL_REQUEST_SET_CARRIER_RESTRICTIONS: return "SET_CARRIER_RESTRICTIONS";
case RIL_REQUEST_GET_CARRIER_RESTRICTIONS: return "GET_CARRIER_RESTRICTIONS";
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
@ -5897,7 +6109,6 @@ requestToString(int request) {
case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
case RIL_UNSOL_SUPP_SVC_NOTIFICATION: return "UNSOL_SUPP_SVC_NOTIFICATION";
case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
@ -5905,6 +6116,7 @@ requestToString(int request) {
case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
@ -5929,11 +6141,12 @@ requestToString(int request) {
case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
case RIL_UNSOL_RADIO_CAPABILITY: return "UNSOL_RADIO_CAPABILITY";
case RIL_UNSOL_ON_SS: return "UNSOL_ON_SS";
case RIL_UNSOL_STK_CC_ALPHA_NOTIFY: return "UNSOL_STK_CC_ALPHA_NOTIFY";
case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
case RIL_RESPONSE_ACKNOWLEDGEMENT: return "RIL_RESPONSE_ACKNOWLEDGEMENT";
case RIL_UNSOL_PCO_DATA: return "RIL_UNSOL_PCO_DATA";
default: return "<unknown request>";
}
}

6
ril/libril/ril_commands.h
Unescape View File

@ -32,7 +32,7 @@
{RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, dispatchVoid, responseVoid},
{RIL_REQUEST_CONFERENCE, dispatchVoid, responseVoid},
{RIL_REQUEST_UDUB, dispatchVoid, responseVoid},
{RIL_REQUEST_LAST_CALL_FAIL_CAUSE, dispatchVoid, responseInts},
{RIL_REQUEST_LAST_CALL_FAIL_CAUSE, dispatchVoid, responseFailCause},
{RIL_REQUEST_SIGNAL_STRENGTH, dispatchVoid, responseRilSignalStrength},
{RIL_REQUEST_VOICE_REGISTRATION_STATE, dispatchVoid, responseStrings},
{RIL_REQUEST_DATA_REGISTRATION_STATE, dispatchVoid, responseStrings},
@ -88,7 +88,7 @@
{RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM, dispatchInts, responseVoid},
{RIL_REQUEST_EXPLICIT_CALL_TRANSFER, dispatchVoid, responseVoid},
{RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, dispatchInts, responseVoid},
{RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE, dispatchVoid, responseIntsGetPreferredNetworkType},
{RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE, dispatchVoid, responseInts},
{RIL_REQUEST_GET_NEIGHBORING_CELL_IDS, dispatchVoid, responseCellList},
{RIL_REQUEST_SET_LOCATION_UPDATES, dispatchInts, responseVoid},
{RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE, dispatchInts, responseVoid},
@ -150,3 +150,5 @@
{RIL_REQUEST_STOP_LCE, dispatchVoid, responseLceStatus},
{RIL_REQUEST_PULL_LCEDATA, dispatchVoid, responseLceData},
{RIL_REQUEST_GET_ACTIVITY_INFO, dispatchVoid, responseActivityData},
{RIL_REQUEST_SET_CARRIER_RESTRICTIONS, dispatchCarrierRestrictions, responseInts},
{RIL_REQUEST_GET_CARRIER_RESTRICTIONS, dispatchVoid, responseCarrierRestrictions},

1
ril/libril/ril_unsol_commands.h
Unescape View File

@ -60,3 +60,4 @@
{RIL_UNSOL_ON_SS, responseSSData, WAKE_PARTIAL},
{RIL_UNSOL_STK_CC_ALPHA_NOTIFY, responseString, WAKE_PARTIAL},
{RIL_UNSOL_LCEDATA_RECV, responseLceData, WAKE_PARTIAL},
{RIL_UNSOL_PCO_DATA, responsePcoData, WAKE_PARTIAL},

Write Preview
Loading…
Cancel
Save