#include <errno.h>
#include <assert.h>
#include <ctype.h>
-#include <alloca.h>
#include <sys/un.h>
#include <assert.h>
#include <netinet/in.h>
extern "C" void
RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen);
+
+extern "C" void
+RIL_onRequestAck(RIL_Token t);
namespace android {
#define PHONE_PROCESS "radio"
/* Constants for response types */
#define RESPONSE_SOLICITED 0
#define RESPONSE_UNSOLICITED 1
+#define RESPONSE_SOLICITED_ACK 2
+#define RESPONSE_SOLICITED_ACK_EXP 3
+#define RESPONSE_UNSOLICITED_ACK_EXP 4
/* Negative values for private RIL errno's */
#define RIL_ERRNO_INVALID_RESPONSE -1
+#define RIL_ERRNO_NO_MEMORY -12
// request, response, and unsolicited msg print macro
#define PRINTBUF_SIZE 8096
char cancelled;
char local; // responses to local commands do not go back to command process
RIL_SOCKET_ID socket_id;
+ int wasAckSent; // Indicates whether an ack was sent earlier
} RequestInfo;
typedef struct UserCallbackInfo {
static int s_fdWakeupRead;
static int s_fdWakeupWrite;
+int s_wakelock_count = 0;
+
static struct ril_event s_commands_event;
static struct ril_event s_wakeupfd_event;
static struct ril_event s_listen_event;
static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_wakeLockCountMutex = PTHREAD_MUTEX_INITIALIZER;
static RequestInfo *s_pendingRequests = NULL;
#if (SIM_COUNT >= 2)
static int decodeVoiceRadioTechnology (RIL_RadioState radioState);
static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
static RIL_RadioState processRadioState(RIL_RadioState newRadioState);
+static void grabPartialWakeLock();
+static void releaseWakeLock();
+static void wakeTimeoutCallback(void *);
static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType);
#endif
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
+ if (pRI == NULL) {
+ RLOGE("Memory allocation failed for request %s", requestToString(request));
+ return;
+ }
pRI->local = 1;
pRI->token = 0xffffffff; // token is not used in this context
return 0;
}
+ // Received an Ack for the previous result sent to RIL.java,
+ // so release wakelock and exit
+ if (request == RIL_RESPONSE_ACKNOWLEDGEMENT) {
+ releaseWakeLock();
+ return 0;
+ }
+
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
+ if (pRI == NULL) {
+ RLOGE("Memory allocation failed for request %s", requestToString(request));
+ return 0;
+ }
pRI->token = token;
pRI->pCI = &(s_commands[request]);
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));
+ closeRequest;
+ return;
+ }
+
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));
+ closeRequest;
+ return;
+ }
for (int i = 0 ; i < countStrings ; i++) {
pStrings[i] = strdupReadString(p);
#ifdef MEMSET_FREED
memset(pStrings, 0, datalen);
#endif
+ free(pStrings);
}
return;
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;
+ }
startRequest;
for (int i = 0 ; i < count ; i++) {
appendPrintBuf("%s%d,", printBuf, t);
if (status != NO_ERROR) {
+ free(pInts);
goto invalid;
}
}
#ifdef MEMSET_FREED
memset(pInts, 0, datalen);
#endif
-
+ free(pInts);
return;
invalid:
invalidCommandBlock(pRI);
(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));
+ closeRequest;
+ return;
+ }
+
datalen = 0;
- } else if (((int)countStrings) == -1) {
+ } else if (countStrings < 0) {
pStrings = NULL;
datalen = 0;
} else {
+ if (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));
+ closeRequest;
+ return;
+ }
for (int i = 0 ; i < countStrings ; i++) {
pStrings[i] = strdupReadString(p);
#ifdef MEMSET_FREED
memset(pStrings, 0, datalen);
#endif
+ free(pStrings);
}
#ifdef MEMSET_FREED
uint8_t uct;
status_t status;
int32_t digitCount;
+ int32_t digitLimit;
memset(&rcsw, 0, sizeof(rcsw));
status = p.read(&uct,sizeof(uct));
rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct,sizeof(uct));
rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
}
status = p.read(&uct,sizeof(uct));
rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct,sizeof(uct));
rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
}
status = p.readInt32(&t);
rcsw.message.uBearerDataLen = (int) t;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct, sizeof(uct));
rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
}
int32_t num;
status = p.readInt32(&num);
- if (status != NO_ERROR) {
+ if (status != NO_ERROR || num < 0) {
goto invalid;
}
{
- RIL_DataProfileInfo dataProfiles[num];
- RIL_DataProfileInfo *dataProfilePtrs[num];
+ RIL_DataProfileInfo *dataProfiles =
+ (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 **)calloc(num, sizeof(RIL_DataProfileInfo *));
+ if (dataProfilePtrs == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ free(dataProfiles);
+ return;
+ }
startRequest;
for (int i = 0 ; i < num ; i++ ) {
printRequest(pRI->token, pRI->pCI->requestNumber);
if (status != NO_ERROR) {
+ free(dataProfiles);
+ free(dataProfilePtrs);
goto invalid;
}
CALL_ONREQUEST(pRI->pCI->requestNumber,
memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo));
memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *));
#endif
+ free(dataProfiles);
+ free(dataProfilePtrs);
}
return;
} else {
return responseDataCallListV11(p, response, responselen);
}
- } else { // RIL version >= 12
+ } else { // RIL version >= 13
if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) {
RLOGE("Data structure expected is RIL_Data_Call_Response_v11");
if (!isDebuggable()) {
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;
+ return RIL_ERRNO_NO_MEMORY;
+ }
for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
string8[i] = infoRec->rec.display.alpha_buf[i];
}
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;
+ return RIL_ERRNO_NO_MEMORY;
+ }
for (int i = 0 ; i < infoRec->rec.number.len; i++) {
string8[i] = infoRec->rec.number.buf[i];
}
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;
+ return RIL_ERRNO_NO_MEMORY;
+ }
for (int i = 0;
i < infoRec->rec.redir.redirectingNumber.len;
i++) {
RLOGE("invalid response length");
return RIL_ERRNO_INVALID_RESPONSE;
}
- } else { // RIL version >= 12
+ } else { // RIL version >= 13
if (responselen % sizeof(RIL_SignalStrength_v10) != 0) {
RLOGE("Data structure expected is RIL_SignalStrength_v10");
if (!isDebuggable()) {
p.writeInt32(0);
p.writeInt32(0);
}
- } else { // RIL version >= 12
+ } else { // RIL version >= 13
if (responselen % sizeof(RIL_CDMA_CallWaiting_v6) != 0) {
RLOGE("Data structure expected is RIL_CDMA_CallWaiting_v6");
if (!isDebuggable()) {
startResponse;
if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
- if (s_callbacks.version == 7) {
+ if (s_callbacks.version >= 7) {
responseSimRefreshV7(p, response);
} else {
int *p_cur = ((int *) response);
p_cur[0],
p_cur[1]);
}
- } else { // RIL version >= 12
+ } else { // RIL version >= 13
if (responselen % sizeof(RIL_SimRefreshResponse_v7) != 0) {
RLOGE("Data structure expected is RIL_SimRefreshResponse_v7");
if (!isDebuggable()) {
return 0;
}
-static int responseCellInfoList(Parcel &p, void *response, size_t responselen)
-{
+static int responseCellInfoListV6(Parcel &p, void *response, size_t responselen) {
if (response == NULL && responselen != 0) {
RLOGE("invalid response: NULL");
return RIL_ERRNO_INVALID_RESPONSE;
startResponse;
int i;
for (i = 0; i < num; i++) {
- appendPrintBuf("%s[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", printBuf, i,
- p_cur->cellInfoType, p_cur->registered, p_cur->timeStampType, p_cur->timeStamp);
p.writeInt32((int)p_cur->cellInfoType);
p.writeInt32(p_cur->registered);
p.writeInt32(p_cur->timeStampType);
p.writeInt64(p_cur->timeStamp);
switch(p_cur->cellInfoType) {
case RIL_CELL_INFO_TYPE_GSM: {
- appendPrintBuf("%s GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,", printBuf,
- p_cur->CellInfo.gsm.cellIdentityGsm.mcc,
- p_cur->CellInfo.gsm.cellIdentityGsm.mnc,
- p_cur->CellInfo.gsm.cellIdentityGsm.lac,
- p_cur->CellInfo.gsm.cellIdentityGsm.cid);
- appendPrintBuf("%s gsmSS: ss=%d,ber=%d],", printBuf,
- p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
- p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
-
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac);
break;
}
case RIL_CELL_INFO_TYPE_WCDMA: {
- appendPrintBuf("%s WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,", printBuf,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.lac,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.cid,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.psc);
- appendPrintBuf("%s wcdmaSS: ss=%d,ber=%d],", printBuf,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
-
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac);
break;
}
case RIL_CELL_INFO_TYPE_CDMA: {
- appendPrintBuf("%s CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d", printBuf,
- p_cur->CellInfo.cdma.cellIdentityCdma.networkId,
- p_cur->CellInfo.cdma.cellIdentityCdma.systemId,
- p_cur->CellInfo.cdma.cellIdentityCdma.basestationId,
- p_cur->CellInfo.cdma.cellIdentityCdma.longitude,
- p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
-
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.networkId);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.systemId);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.basestationId);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.longitude);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
- appendPrintBuf("%s cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d", printBuf,
- p_cur->CellInfo.cdma.signalStrengthCdma.dbm,
- p_cur->CellInfo.cdma.signalStrengthCdma.ecio,
- p_cur->CellInfo.cdma.signalStrengthEvdo.dbm,
- p_cur->CellInfo.cdma.signalStrengthEvdo.ecio,
- p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
-
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm);
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio);
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm);
break;
}
case RIL_CELL_INFO_TYPE_LTE: {
- appendPrintBuf("%s LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d", printBuf,
- p_cur->CellInfo.lte.cellIdentityLte.mcc,
- p_cur->CellInfo.lte.cellIdentityLte.mnc,
- p_cur->CellInfo.lte.cellIdentityLte.ci,
- p_cur->CellInfo.lte.cellIdentityLte.pci,
- p_cur->CellInfo.lte.cellIdentityLte.tac);
-
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mcc);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mnc);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.ci);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.pci);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.tac);
- appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf,
- p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
- p_cur->CellInfo.lte.signalStrengthLte.rsrp,
- p_cur->CellInfo.lte.signalStrengthLte.rsrq,
- p_cur->CellInfo.lte.signalStrengthLte.rssnr,
- p_cur->CellInfo.lte.signalStrengthLte.cqi,
- p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq);
break;
}
case RIL_CELL_INFO_TYPE_TD_SCDMA: {
- appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
- appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf,
- p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid);
+ p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
+ p.writeInt32(p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
+ break;
+ }
+ }
+ p_cur += 1;
+ }
+ removeLastChar;
+ closeResponse;
+
+ return 0;
+}
+
+static int responseCellInfoListV12(Parcel &p, void *response, size_t responselen) {
+ if (response == NULL && responselen != 0) {
+ RLOGE("invalid response: NULL");
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ if (responselen % sizeof(RIL_CellInfo_v12) != 0) {
+ RLOGE("responseCellInfoList: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_CellInfo_v12));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ int num = responselen / sizeof(RIL_CellInfo_v12);
+ p.writeInt32(num);
+
+ RIL_CellInfo_v12 *p_cur = (RIL_CellInfo_v12 *) response;
+ startResponse;
+ int i;
+ for (i = 0; i < num; i++) {
+ p.writeInt32((int)p_cur->cellInfoType);
+ p.writeInt32(p_cur->registered);
+ p.writeInt32(p_cur->timeStampType);
+ p.writeInt64(p_cur->timeStamp);
+ switch(p_cur->cellInfoType) {
+ case RIL_CELL_INFO_TYPE_GSM: {
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc);
+ 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(p_cur->CellInfo.gsm.cellIdentityGsm.arfcn);
+ p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.bsic);
+ p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength);
+ p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
+ p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.timingAdvance);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_WCDMA: {
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc);
+ p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc);
+ 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(p_cur->CellInfo.wcdma.cellIdentityWcdma.uarfcn);
+ p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength);
+ p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_CDMA: {
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.networkId);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.systemId);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.basestationId);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.longitude);
+ p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.ecio);
+ p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_LTE: {
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mcc);
+ p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mnc);
+ 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(p_cur->CellInfo.lte.cellIdentityLte.earfcn);
+
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rssnr);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.cqi);
+ p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
+ break;
+ }
+ case RIL_CELL_INFO_TYPE_TD_SCDMA: {
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
}
removeLastChar;
closeResponse;
+ return 0;
+}
+
+static int responseCellInfoList(Parcel &p, void *response, size_t responselen)
+{
+ if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
+ if (s_callbacks.version < 12) {
+ RLOGD("responseCellInfoList: v6");
+ return responseCellInfoListV6(p, response, responselen);
+ } else {
+ RLOGD("responseCellInfoList: v12");
+ return responseCellInfoListV12(p, response, responselen);
+ }
+ } else { // RIL version >= 13
+ if (responselen % sizeof(RIL_CellInfo_v12) != 0) {
+ RLOGE("Data structure expected is RIL_CellInfo_v12");
+ if (!isDebuggable()) {
+ return RIL_ERRNO_INVALID_RESPONSE;
+ } else {
+ assert(0);
+ }
+ }
+ return responseCellInfoListV12(p, response, responselen);
+ }
return 0;
}
RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
return RIL_ERRNO_INVALID_RESPONSE;
}
- } else { // RIL version >= 12
+ } else { // RIL version >= 13
if (responselen % sizeof(RIL_CardStatus_v6) != 0) {
RLOGE("Data structure expected is RIL_CardStatus_v6");
if (!isDebuggable()) {
if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
RLOGE ("error reading on socket: number of Args: \n");
+ close(acceptFD);
+ return;
+ }
+
+ 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);
return;
}
- args = (char **) malloc(sizeof(char*) * number);
for (int i = 0; i < number; i++) {
int len;
if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
RLOGE ("error reading on socket: Len of Args: \n");
freeDebugCallbackArgs(i, args);
+ close(acceptFD);
+ 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);
+ close(acceptFD);
+ return;
+ }
if (recv(acceptFD, args[i], sizeof(char) * len, 0)
!= (int)sizeof(char) * len) {
RLOGE ("error reading on socket: Args[%d] \n", i);
freeDebugCallbackArgs(i, args);
+ close(acceptFD);
return;
}
char * buf = args[i];
}
}
+// Check and remove RequestInfo if its a response and not just ack sent back
static int
-checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
+checkAndDequeueRequestInfoIfAck(struct RequestInfo *pRI, bool isAck) {
int ret = 0;
/* Hook for current context
pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
) {
if (pRI == *ppCur) {
ret = 1;
-
- *ppCur = (*ppCur)->p_next;
+ if (isAck) { // Async ack
+ if (pRI->wasAckSent == 1) {
+ RLOGD("Ack was already sent for %s", requestToString(pRI->pCI->requestNumber));
+ } else {
+ pRI->wasAckSent = 1;
+ }
+ } else {
+ *ppCur = (*ppCur)->p_next;
+ }
break;
}
}
return ret;
}
+static int findFd(int socket_id) {
+ int fd = s_ril_param_socket.fdCommand;
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ fd = s_ril_param_socket2.fdCommand;
+ }
+#if (SIM_COUNT >= 3)
+ if (socket_id == RIL_SOCKET_3) {
+ fd = s_ril_param_socket3.fdCommand;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ if (socket_id == RIL_SOCKET_4) {
+ fd = s_ril_param_socket4.fdCommand;
+ }
+#endif
+#endif
+ return fd;
+}
+
+extern "C" void
+RIL_onRequestAck(RIL_Token t) {
+ RequestInfo *pRI;
+ int ret, fd;
+
+ size_t errorOffset;
+ RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
+
+ pRI = (RequestInfo *)t;
+
+ if (!checkAndDequeueRequestInfoIfAck(pRI, true)) {
+ RLOGE ("RIL_onRequestAck: invalid RIL_Token");
+ return;
+ }
+
+ socket_id = pRI->socket_id;
+ fd = findFd(socket_id);
+
+#if VDBG
+ RLOGD("Request Ack, %s", rilSocketIdToString(socket_id));
+#endif
+
+ appendPrintBuf("Ack [%04d]< %s", pRI->token, requestToString(pRI->pCI->requestNumber));
+
+ if (pRI->cancelled == 0) {
+ Parcel p;
+
+ p.writeInt32 (RESPONSE_SOLICITED_ACK);
+ p.writeInt32 (pRI->token);
+
+ if (fd < 0) {
+ RLOGD ("RIL onRequestComplete: Command channel closed");
+ }
+
+ sendResponse(p, socket_id);
+ }
+}
extern "C" void
RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
RequestInfo *pRI;
int ret;
- int fd = s_ril_param_socket.fdCommand;
+ int fd;
size_t errorOffset;
RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
pRI = (RequestInfo *)t;
- if (!checkAndDequeueRequestInfo(pRI)) {
+ if (!checkAndDequeueRequestInfoIfAck(pRI, false)) {
RLOGE ("RIL_onRequestComplete: invalid RIL_Token");
return;
}
socket_id = pRI->socket_id;
-#if (SIM_COUNT >= 2)
- if (socket_id == RIL_SOCKET_2) {
- fd = s_ril_param_socket2.fdCommand;
- }
-#if (SIM_COUNT >= 3)
- if (socket_id == RIL_SOCKET_3) {
- fd = s_ril_param_socket3.fdCommand;
- }
-#endif
-#if (SIM_COUNT >= 4)
- if (socket_id == RIL_SOCKET_4) {
- fd = s_ril_param_socket4.fdCommand;
- }
-#endif
-#endif
+ fd = findFd(socket_id);
+
#if VDBG
RLOGD("RequestComplete, %s", rilSocketIdToString(socket_id));
#endif
if (pRI->cancelled == 0) {
Parcel p;
- p.writeInt32 (RESPONSE_SOLICITED);
+ if (s_callbacks.version >= 13 && pRI->wasAckSent == 1) {
+ // If ack was already sent, then this call is an asynchronous response. So we need to
+ // send id indicating that we expect an ack from RIL.java as we acquire wakelock here.
+ p.writeInt32 (RESPONSE_SOLICITED_ACK_EXP);
+ grabPartialWakeLock();
+ } else {
+ p.writeInt32 (RESPONSE_SOLICITED);
+ }
p.writeInt32 (pRI->token);
errorOffset = p.dataPosition();
free(pRI);
}
-
static void
grabPartialWakeLock() {
- acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
+ if (s_callbacks.version >= 13) {
+ int ret;
+ ret = pthread_mutex_lock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
+
+ UserCallbackInfo *p_info =
+ internalRequestTimedCallback(wakeTimeoutCallback, NULL, &TIMEVAL_WAKE_TIMEOUT);
+ if (p_info == NULL) {
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ } else {
+ s_wakelock_count++;
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
+ s_last_wake_timeout_info = p_info;
+ }
+ ret = pthread_mutex_unlock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ } else {
+ acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
+ }
}
static void
releaseWakeLock() {
- release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ if (s_callbacks.version >= 13) {
+ int ret;
+ ret = pthread_mutex_lock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+
+ if (s_wakelock_count > 1) {
+ s_wakelock_count--;
+ } else {
+ s_wakelock_count = 0;
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
+ }
+
+ ret = pthread_mutex_unlock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ } else {
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ }
}
/**
static void
wakeTimeoutCallback (void *param) {
// We're using "param != NULL" as a cancellation mechanism
- if (param == NULL) {
- releaseWakeLock();
+ if (s_callbacks.version >= 13) {
+ if (param == NULL) {
+ int ret;
+ ret = pthread_mutex_lock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ s_wakelock_count = 0;
+ release_wake_lock(ANDROID_WAKE_LOCK_NAME);
+ ret = pthread_mutex_unlock(&s_wakeLockCountMutex);
+ assert(ret == 0);
+ }
+ } else {
+ if (param == NULL) {
+ releaseWakeLock();
+ }
}
}
appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
Parcel p;
-
- p.writeInt32 (RESPONSE_UNSOLICITED);
+ if (s_callbacks.version >= 13
+ && s_unsolResponses[unsolResponseIndex].wakeType == WAKE_PARTIAL) {
+ p.writeInt32 (RESPONSE_UNSOLICITED_ACK_EXP);
+ } else {
+ p.writeInt32 (RESPONSE_UNSOLICITED);
+ }
p.writeInt32 (unsolResponse);
ret = s_unsolResponses[unsolResponseIndex]
break;
}
+ if (s_callbacks.version < 13) {
+ if (shouldScheduleTimeout) {
+ UserCallbackInfo *p_info = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
+ &TIMEVAL_WAKE_TIMEOUT);
+
+ if (p_info == NULL) {
+ goto error_exit;
+ } else {
+ // Cancel the previous request
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
+ s_last_wake_timeout_info = p_info;
+ }
+ }
+ }
+
#if VDBG
RLOGI("%s UNSOLICITED: %s length:%d", rilSocketIdToString(soc_id), requestToString(unsolResponse), p.dataSize());
#endif
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;
+ }
s_lastNITZTimeDataSize = p.dataSize();
memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
}
- // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
- // FIXME The java code should handshake here to release wake lock
-
- if (shouldScheduleTimeout) {
- // Cancel the previous request
- if (s_last_wake_timeout_info != NULL) {
- s_last_wake_timeout_info->userParam = (void *)1;
- }
-
- s_last_wake_timeout_info
- = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
- &TIMEVAL_WAKE_TIMEOUT);
- }
-
// Normal exit
return;
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;
+
+ }
p_info->p_callback = callback;
p_info->userParam = param;
case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
#endif
+ case RIL_E_FDN_CHECK_FAILURE: return "E_FDN_CHECK_FAILURE";
+ case RIL_E_MISSING_RESOURCE: return "E_MISSING_RESOURCE";
+ case RIL_E_NO_SUCH_ELEMENT: return "E_NO_SUCH_ELEMENT";
+ case RIL_E_DIAL_MODIFIED_TO_USSD: return "E_DIAL_MODIFIED_TO_USSD";
+ case RIL_E_DIAL_MODIFIED_TO_SS: return "E_DIAL_MODIFIED_TO_SS";
+ case RIL_E_DIAL_MODIFIED_TO_DIAL: return "E_DIAL_MODIFIED_TO_DIAL";
+ case RIL_E_USSD_MODIFIED_TO_DIAL: return "E_USSD_MODIFIED_TO_DIAL";
+ case RIL_E_USSD_MODIFIED_TO_SS: return "E_USSD_MODIFIED_TO_SS";
+ case RIL_E_USSD_MODIFIED_TO_USSD: return "E_USSD_MODIFIED_TO_USSD";
+ case RIL_E_SS_MODIFIED_TO_DIAL: return "E_SS_MODIFIED_TO_DIAL";
+ case RIL_E_SS_MODIFIED_TO_USSD: return "E_SS_MODIFIED_TO_USSD";
+ case RIL_E_SUBSCRIPTION_NOT_SUPPORTED: return "E_SUBSCRIPTION_NOT_SUPPORTED";
+ case RIL_E_SS_MODIFIED_TO_SS: return "E_SS_MODIFIED_TO_SS";
+ case RIL_E_LCE_NOT_SUPPORTED: return "E_LCE_NOT_SUPPORTED";
+ case RIL_E_NO_MEMORY: return "E_NO_MEMORY";
+ case RIL_E_INTERNAL_ERR: return "E_INTERNAL_ERR";
+ case RIL_E_SYSTEM_ERR: return "E_SYSTEM_ERR";
+ case RIL_E_MODEM_ERR: return "E_MODEM_ERR";
+ case RIL_E_INVALID_STATE: return "E_INVALID_STATE";
+ case RIL_E_NO_RESOURCES: return "E_NO_RESOURCES";
+ case RIL_E_SIM_ERR: return "E_SIM_ERR";
+ case RIL_E_INVALID_ARGUMENTS: return "E_INVALID_ARGUMENTS";
+ case RIL_E_INVALID_SIM_STATE: return "E_INVALID_SIM_STATE";
+ case RIL_E_INVALID_MODEM_STATE: return "E_INVALID_MODEM_STATE";
+ case RIL_E_INVALID_CALL_ID: return "E_INVALID_CALL_ID";
+ case RIL_E_NO_SMS_TO_ACK: return "E_NO_SMS_TO_ACK";
+ case RIL_E_NETWORK_ERR: return "E_NETWORK_ERR";
+ case RIL_E_REQUEST_RATE_LIMITED: return "E_REQUEST_RATE_LIMITED";
+ case RIL_E_SIM_BUSY: return "E_SIM_BUSY";
+ case RIL_E_SIM_FULL: return "E_SIM_FULL";
+ case RIL_E_NETWORK_REJECT: return "E_NETWORK_REJECT";
+ case RIL_E_OPERATION_NOT_ALLOWED: return "E_OPERATION_NOT_ALLOWED";
+ case RIL_E_EMPTY_RECORD: "E_EMPTY_RECORD";
+ case RIL_E_OEM_ERROR_1: return "E_OEM_ERROR_1";
+ case RIL_E_OEM_ERROR_2: return "E_OEM_ERROR_2";
+ case RIL_E_OEM_ERROR_3: return "E_OEM_ERROR_3";
+ case RIL_E_OEM_ERROR_4: return "E_OEM_ERROR_4";
+ case RIL_E_OEM_ERROR_5: return "E_OEM_ERROR_5";
+ case RIL_E_OEM_ERROR_6: return "E_OEM_ERROR_6";
+ case RIL_E_OEM_ERROR_7: return "E_OEM_ERROR_7";
+ case RIL_E_OEM_ERROR_8: return "E_OEM_ERROR_8";
+ case RIL_E_OEM_ERROR_9: return "E_OEM_ERROR_9";
+ case RIL_E_OEM_ERROR_10: return "E_OEM_ERROR_10";
+ case RIL_E_OEM_ERROR_11: return "E_OEM_ERROR_11";
+ case RIL_E_OEM_ERROR_12: return "E_OEM_ERROR_12";
+ case RIL_E_OEM_ERROR_13: return "E_OEM_ERROR_13";
+ case RIL_E_OEM_ERROR_14: return "E_OEM_ERROR_14";
+ case RIL_E_OEM_ERROR_15: return "E_OEM_ERROR_15";
+ case RIL_E_OEM_ERROR_16: return "E_OEM_ERROR_16";
+ case RIL_E_OEM_ERROR_17: return "E_OEM_ERROR_17";
+ case RIL_E_OEM_ERROR_18: return "E_OEM_ERROR_18";
+ case RIL_E_OEM_ERROR_19: return "E_OEM_ERROR_19";
+ case RIL_E_OEM_ERROR_20: return "E_OEM_ERROR_20";
+ case RIL_E_OEM_ERROR_21: return "E_OEM_ERROR_21";
+ case RIL_E_OEM_ERROR_22: return "E_OEM_ERROR_22";
+ case RIL_E_OEM_ERROR_23: return "E_OEM_ERROR_23";
+ case RIL_E_OEM_ERROR_24: return "E_OEM_ERROR_24";
+ case RIL_E_OEM_ERROR_25: return "E_OEM_ERROR_25";
default: return "<unknown error>";
}
}
case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
+ case RIL_REQUEST_WRITE_SMS_TO_SIM: return "WRITE_SMS_TO_SIM";
case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
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_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";
case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
+ case RIL_RESPONSE_ACKNOWLEDGEMENT: return "RIL_RESPONSE_ACKNOWLEDGEMENT";
default: return "<unknown request>";
}
}
OSDN Git Service
