X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=libril%2Fril.cpp;h=08035636187b87553eede3eda6faad7b5be9fdb8;hb=ab379831bc;hp=bb2aa7d9fb862111c90e378b4c1e78420661fa8b;hpb=e66a47c150f6564e63f33f0b0144e85a622d5cac;p=android-x86%2Fhardware-ril.git diff --git a/libril/ril.cpp b/libril/ril.cpp index bb2aa7d..0803563 100644 --- a/libril/ril.cpp +++ b/libril/ril.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -41,7 +42,6 @@ #include #include #include -#include #include #include #include @@ -50,6 +50,9 @@ 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" @@ -84,9 +87,13 @@ namespace android { /* 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 @@ -109,7 +116,7 @@ namespace android { #define clearPrintBuf printBuf[0] = 0 #define removeLastChar printBuf[strlen(printBuf)-1] = 0 - #define appendPrintBuf(x...) sprintf(printBuf, x) + #define appendPrintBuf(x...) snprintf(printBuf, PRINTBUF_SIZE, x) #else #define startRequest #define closeRequest @@ -143,6 +150,7 @@ typedef struct RequestInfo { 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 { @@ -175,6 +183,8 @@ static int s_fdDebug_socket2 = -1; 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; @@ -182,6 +192,7 @@ static SocketListenParam s_ril_param_socket; 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) @@ -271,6 +282,7 @@ 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 responseFailCause(Parcel &p, void *response, size_t responselen); static int responseStrings(Parcel &p, void *response, size_t responselen); @@ -303,13 +315,20 @@ static int responseSSData(Parcel &p, void *response, size_t responselen); 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); +static void grabPartialWakeLock(); +static void releaseWakeLock(); +static void wakeTimeoutCallback(void *); static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType); +static bool isDebuggable(); + #ifdef RIL_SHLIB #if defined(ANDROID_MULTI_SIM) extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, @@ -447,6 +466,10 @@ issueLocalRequest(int request, void *data, int len, RIL_SOCKET_ID socket_id) { #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 @@ -513,6 +536,13 @@ processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) { 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; + } + if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) { Parcel pErr; RLOGE("unsupported request code %d token %d", request, token); @@ -525,8 +555,11 @@ processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) { 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]); @@ -608,15 +641,28 @@ 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)); + 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); @@ -640,6 +686,7 @@ dispatchStrings (Parcel &p, RequestInfo *pRI) { #ifdef MEMSET_FREED memset(pStrings, 0, datalen); #endif + free(pStrings); } return; @@ -658,12 +705,16 @@ 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; + } startRequest; for (int i = 0 ; i < count ; i++) { @@ -674,6 +725,7 @@ dispatchInts (Parcel &p, RequestInfo *pRI) { appendPrintBuf("%s%d,", printBuf, t); if (status != NO_ERROR) { + free(pInts); goto invalid; } } @@ -687,7 +739,7 @@ dispatchInts (Parcel &p, RequestInfo *pRI) { #ifdef MEMSET_FREED memset(pInts, 0, datalen); #endif - + free(pInts); return; invalid: invalidCommandBlock(pRI); @@ -1267,15 +1319,33 @@ 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)); + closeRequest; + return; + } + 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)); + closeRequest; + return; + } for (int i = 0 ; i < countStrings ; i++) { pStrings[i] = strdupReadString(p); @@ -1302,6 +1372,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 @@ -1521,6 +1592,7 @@ static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) { uint8_t uct; status_t status; int32_t digitCount; + int32_t digitLimit; memset(&rcsw, 0, sizeof(rcsw)); @@ -1551,7 +1623,9 @@ static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) { 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; } @@ -1565,7 +1639,9 @@ static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) { 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; } @@ -1573,7 +1649,9 @@ static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) { 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; } @@ -1914,13 +1992,26 @@ 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[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++ ) { @@ -1962,6 +2053,8 @@ static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) { printRequest(pRI->token, pRI->pCI->requestNumber); if (status != NO_ERROR) { + free(dataProfiles); + free(dataProfilePtrs); goto invalid; } CALL_ONREQUEST(pRI->pCI->requestNumber, @@ -1973,6 +2066,8 @@ static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) { memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo)); memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *)); #endif + free(dataProfiles); + free(dataProfilePtrs); } return; @@ -2027,7 +2122,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 + logicalModemUuid:%s, status:%d", printBuf, rc.version, rc.session, rc.phase, rc.rat, rc.logicalModemUuid, rc.session); closeRequest; @@ -2043,6 +2138,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(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(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; @@ -2506,69 +2700,84 @@ static int responseDataCallListV9(Parcel &p, void *response, size_t responselen) return 0; } +static int responseDataCallListV11(Parcel &p, void *response, size_t responselen) { + if (response == NULL && responselen != 0) { + RLOGE("invalid response: NULL"); + return RIL_ERRNO_INVALID_RESPONSE; + } -static int responseDataCallList(Parcel &p, void *response, size_t responselen) -{ - if (s_callbacks.version < 5) { - RLOGD("responseDataCallList: v4"); - return responseDataCallListV4(p, response, responselen); - } else if (responselen % sizeof(RIL_Data_Call_Response_v6) == 0) { - return responseDataCallListV6(p, response, responselen); - } else if (responselen % sizeof(RIL_Data_Call_Response_v9) == 0) { - return responseDataCallListV9(p, response, responselen); - } else { - if (response == NULL && responselen != 0) { - RLOGE("invalid response: NULL"); - return RIL_ERRNO_INVALID_RESPONSE; - } - - if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) { - RLOGE("invalid response length %d expected multiple of %d", - (int)responselen, (int)sizeof(RIL_Data_Call_Response_v11)); - return RIL_ERRNO_INVALID_RESPONSE; - } + if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) { + RLOGE("invalid response length %d expected multiple of %d", + (int)responselen, (int)sizeof(RIL_Data_Call_Response_v11)); + return RIL_ERRNO_INVALID_RESPONSE; + } - // Write version - p.writeInt32(11); + // Write version + p.writeInt32(11); - int num = responselen / sizeof(RIL_Data_Call_Response_v11); - p.writeInt32(num); + int num = responselen / sizeof(RIL_Data_Call_Response_v11); + p.writeInt32(num); - RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *) response; - startResponse; - int i; - for (i = 0; i < num; i++) { - p.writeInt32((int)p_cur[i].status); - p.writeInt32(p_cur[i].suggestedRetryTime); - p.writeInt32(p_cur[i].cid); - p.writeInt32(p_cur[i].active); - writeStringToParcel(p, p_cur[i].type); - writeStringToParcel(p, p_cur[i].ifname); - writeStringToParcel(p, p_cur[i].addresses); - writeStringToParcel(p, p_cur[i].dnses); - writeStringToParcel(p, p_cur[i].gateways); - writeStringToParcel(p, p_cur[i].pcscf); - p.writeInt32(p_cur[i].mtu); - appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s,mtu=%d],", printBuf, - p_cur[i].status, - p_cur[i].suggestedRetryTime, - p_cur[i].cid, - (p_cur[i].active==0)?"down":"up", - (char*)p_cur[i].type, - (char*)p_cur[i].ifname, - (char*)p_cur[i].addresses, - (char*)p_cur[i].dnses, - (char*)p_cur[i].gateways, - (char*)p_cur[i].pcscf, - p_cur[i].mtu); - } - removeLastChar; - closeResponse; + RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *) response; + startResponse; + int i; + for (i = 0; i < num; i++) { + p.writeInt32((int)p_cur[i].status); + p.writeInt32(p_cur[i].suggestedRetryTime); + p.writeInt32(p_cur[i].cid); + p.writeInt32(p_cur[i].active); + writeStringToParcel(p, p_cur[i].type); + writeStringToParcel(p, p_cur[i].ifname); + writeStringToParcel(p, p_cur[i].addresses); + writeStringToParcel(p, p_cur[i].dnses); + writeStringToParcel(p, p_cur[i].gateways); + writeStringToParcel(p, p_cur[i].pcscf); + p.writeInt32(p_cur[i].mtu); + appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s,mtu=%d],", printBuf, + p_cur[i].status, + p_cur[i].suggestedRetryTime, + p_cur[i].cid, + (p_cur[i].active==0)?"down":"up", + (char*)p_cur[i].type, + (char*)p_cur[i].ifname, + (char*)p_cur[i].addresses, + (char*)p_cur[i].dnses, + (char*)p_cur[i].gateways, + (char*)p_cur[i].pcscf, + p_cur[i].mtu); } + removeLastChar; + closeResponse; return 0; } +static int responseDataCallList(Parcel &p, void *response, size_t responselen) +{ + if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) { + if (s_callbacks.version < 5) { + RLOGD("responseDataCallList: v4"); + return responseDataCallListV4(p, response, responselen); + } else if (responselen % sizeof(RIL_Data_Call_Response_v6) == 0) { + return responseDataCallListV6(p, response, responselen); + } else if (responselen % sizeof(RIL_Data_Call_Response_v9) == 0) { + return responseDataCallListV9(p, response, responselen); + } else { + return responseDataCallListV11(p, response, responselen); + } + } 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()) { + return RIL_ERRNO_INVALID_RESPONSE; + } else { + assert(0); + } + } + return responseDataCallListV11(p, response, responselen); + } +} + static int responseSetupDataCall(Parcel &p, void *response, size_t responselen) { if (s_callbacks.version < 5) { @@ -2775,8 +2984,12 @@ 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; + return RIL_ERRNO_NO_MEMORY; + } for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) { string8[i] = infoRec->rec.display.alpha_buf[i]; } @@ -2795,8 +3008,12 @@ 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; + return RIL_ERRNO_NO_MEMORY; + } for (int i = 0 ; i < infoRec->rec.number.len; i++) { string8[i] = infoRec->rec.number.buf[i]; } @@ -2832,8 +3049,13 @@ 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; + return RIL_ERRNO_NO_MEMORY; + } for (int i = 0; i < infoRec->rec.redir.redirectingNumber.len; i++) { @@ -2893,6 +3115,55 @@ static int responseCdmaInformationRecords(Parcel &p, return 0; } +static void responseRilSignalStrengthV5(Parcel &p, RIL_SignalStrength_v10 *p_cur) { + p.writeInt32(p_cur->GW_SignalStrength.signalStrength); + p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate); + p.writeInt32(p_cur->CDMA_SignalStrength.dbm); + p.writeInt32(p_cur->CDMA_SignalStrength.ecio); + p.writeInt32(p_cur->EVDO_SignalStrength.dbm); + p.writeInt32(p_cur->EVDO_SignalStrength.ecio); + p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio); +} + +static void responseRilSignalStrengthV6Extra(Parcel &p, RIL_SignalStrength_v10 *p_cur) { + /* + * Fixup LTE for backwards compatibility + */ + // signalStrength: -1 -> 99 + if (p_cur->LTE_SignalStrength.signalStrength == -1) { + p_cur->LTE_SignalStrength.signalStrength = 99; + } + // rsrp: -1 -> INT_MAX all other negative value to positive. + // So remap here + if (p_cur->LTE_SignalStrength.rsrp == -1) { + p_cur->LTE_SignalStrength.rsrp = INT_MAX; + } else if (p_cur->LTE_SignalStrength.rsrp < -1) { + p_cur->LTE_SignalStrength.rsrp = -p_cur->LTE_SignalStrength.rsrp; + } + // rsrq: -1 -> INT_MAX + if (p_cur->LTE_SignalStrength.rsrq == -1) { + p_cur->LTE_SignalStrength.rsrq = INT_MAX; + } + // Not remapping rssnr is already using INT_MAX + + // cqi: -1 -> INT_MAX + if (p_cur->LTE_SignalStrength.cqi == -1) { + p_cur->LTE_SignalStrength.cqi = INT_MAX; + } + + p.writeInt32(p_cur->LTE_SignalStrength.signalStrength); + p.writeInt32(p_cur->LTE_SignalStrength.rsrp); + p.writeInt32(p_cur->LTE_SignalStrength.rsrq); + p.writeInt32(p_cur->LTE_SignalStrength.rssnr); + p.writeInt32(p_cur->LTE_SignalStrength.cqi); +} + +static void responseRilSignalStrengthV10(Parcel &p, RIL_SignalStrength_v10 *p_cur) { + responseRilSignalStrengthV5(p, p_cur); + responseRilSignalStrengthV6Extra(p, p_cur); + p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp); +} + static int responseRilSignalStrength(Parcel &p, void *response, size_t responselen) { if (response == NULL && responselen != 0) { @@ -2900,90 +3171,66 @@ static int responseRilSignalStrength(Parcel &p, return RIL_ERRNO_INVALID_RESPONSE; } - if (responselen >= sizeof (RIL_SignalStrength_v5)) { - RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response); - - p.writeInt32(p_cur->GW_SignalStrength.signalStrength); - p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate); - p.writeInt32(p_cur->CDMA_SignalStrength.dbm); - p.writeInt32(p_cur->CDMA_SignalStrength.ecio); - p.writeInt32(p_cur->EVDO_SignalStrength.dbm); - p.writeInt32(p_cur->EVDO_SignalStrength.ecio); - p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio); - if (responselen >= sizeof (RIL_SignalStrength_v6)) { - /* - * Fixup LTE for backwards compatibility - */ - if (s_callbacks.version <= 6) { - // signalStrength: -1 -> 99 - if (p_cur->LTE_SignalStrength.signalStrength == -1) { - p_cur->LTE_SignalStrength.signalStrength = 99; - } - // rsrp: -1 -> INT_MAX all other negative value to positive. - // So remap here - if (p_cur->LTE_SignalStrength.rsrp == -1) { - p_cur->LTE_SignalStrength.rsrp = INT_MAX; - } else if (p_cur->LTE_SignalStrength.rsrp < -1) { - p_cur->LTE_SignalStrength.rsrp = -p_cur->LTE_SignalStrength.rsrp; - } - // rsrq: -1 -> INT_MAX - if (p_cur->LTE_SignalStrength.rsrq == -1) { - p_cur->LTE_SignalStrength.rsrq = INT_MAX; - } - // Not remapping rssnr is already using INT_MAX + RIL_SignalStrength_v10 *p_cur; + if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) { + if (responselen >= sizeof (RIL_SignalStrength_v5)) { + p_cur = ((RIL_SignalStrength_v10 *) response); - // cqi: -1 -> INT_MAX - if (p_cur->LTE_SignalStrength.cqi == -1) { - p_cur->LTE_SignalStrength.cqi = INT_MAX; + responseRilSignalStrengthV5(p, p_cur); + + if (responselen >= sizeof (RIL_SignalStrength_v6)) { + responseRilSignalStrengthV6Extra(p, p_cur); + if (responselen >= sizeof (RIL_SignalStrength_v10)) { + p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp); + } else { + p.writeInt32(INT_MAX); } - } - p.writeInt32(p_cur->LTE_SignalStrength.signalStrength); - p.writeInt32(p_cur->LTE_SignalStrength.rsrp); - p.writeInt32(p_cur->LTE_SignalStrength.rsrq); - p.writeInt32(p_cur->LTE_SignalStrength.rssnr); - p.writeInt32(p_cur->LTE_SignalStrength.cqi); - if (responselen >= sizeof (RIL_SignalStrength_v10)) { - p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp); } else { + p.writeInt32(99); + p.writeInt32(INT_MAX); + p.writeInt32(INT_MAX); + p.writeInt32(INT_MAX); + p.writeInt32(INT_MAX); p.writeInt32(INT_MAX); } } else { - p.writeInt32(99); - p.writeInt32(INT_MAX); - p.writeInt32(INT_MAX); - p.writeInt32(INT_MAX); - p.writeInt32(INT_MAX); - p.writeInt32(INT_MAX); + RLOGE("invalid response length"); + return RIL_ERRNO_INVALID_RESPONSE; } - - startResponse; - appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\ - CDMA_SS.dbm=%d,CDMA_SSecio=%d,\ - EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\ - EVDO_SS.signalNoiseRatio=%d,\ - LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\ - LTE_SS.rssnr=%d,LTE_SS.cqi=%d,TDSCDMA_SS.rscp=%d]", - printBuf, - p_cur->GW_SignalStrength.signalStrength, - p_cur->GW_SignalStrength.bitErrorRate, - p_cur->CDMA_SignalStrength.dbm, - p_cur->CDMA_SignalStrength.ecio, - p_cur->EVDO_SignalStrength.dbm, - p_cur->EVDO_SignalStrength.ecio, - p_cur->EVDO_SignalStrength.signalNoiseRatio, - p_cur->LTE_SignalStrength.signalStrength, - p_cur->LTE_SignalStrength.rsrp, - p_cur->LTE_SignalStrength.rsrq, - p_cur->LTE_SignalStrength.rssnr, - p_cur->LTE_SignalStrength.cqi, - p_cur->TD_SCDMA_SignalStrength.rscp); - closeResponse; - - } else { - RLOGE("invalid response length"); - return RIL_ERRNO_INVALID_RESPONSE; + } else { // RIL version >= 13 + if (responselen % sizeof(RIL_SignalStrength_v10) != 0) { + RLOGE("Data structure expected is RIL_SignalStrength_v10"); + if (!isDebuggable()) { + return RIL_ERRNO_INVALID_RESPONSE; + } else { + assert(0); + } + } + p_cur = ((RIL_SignalStrength_v10 *) response); + responseRilSignalStrengthV10(p, p_cur); } - + startResponse; + appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\ + CDMA_SS.dbm=%d,CDMA_SSecio=%d,\ + EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\ + EVDO_SS.signalNoiseRatio=%d,\ + LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\ + LTE_SS.rssnr=%d,LTE_SS.cqi=%d,TDSCDMA_SS.rscp=%d]", + printBuf, + p_cur->GW_SignalStrength.signalStrength, + p_cur->GW_SignalStrength.bitErrorRate, + p_cur->CDMA_SignalStrength.dbm, + p_cur->CDMA_SignalStrength.ecio, + p_cur->EVDO_SignalStrength.dbm, + p_cur->EVDO_SignalStrength.ecio, + p_cur->EVDO_SignalStrength.signalNoiseRatio, + p_cur->LTE_SignalStrength.signalStrength, + p_cur->LTE_SignalStrength.rsrp, + p_cur->LTE_SignalStrength.rsrq, + p_cur->LTE_SignalStrength.rssnr, + p_cur->LTE_SignalStrength.cqi, + p_cur->TD_SCDMA_SignalStrength.rscp); + closeResponse; return 0; } @@ -3042,12 +3289,25 @@ static int responseCdmaCallWaiting(Parcel &p, void *response, writeStringToParcel(p, p_cur->name); marshallSignalInfoRecord(p, p_cur->signalInfoRecord); - if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) { + if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) { + if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) { + p.writeInt32(p_cur->number_type); + p.writeInt32(p_cur->number_plan); + } else { + p.writeInt32(0); + p.writeInt32(0); + } + } else { // RIL version >= 13 + if (responselen % sizeof(RIL_CDMA_CallWaiting_v6) != 0) { + RLOGE("Data structure expected is RIL_CDMA_CallWaiting_v6"); + if (!isDebuggable()) { + return RIL_ERRNO_INVALID_RESPONSE; + } else { + assert(0); + } + } p.writeInt32(p_cur->number_type); p.writeInt32(p_cur->number_plan); - } else { - p.writeInt32(0); - p.writeInt32(0); } startResponse; @@ -3069,6 +3329,20 @@ static int responseCdmaCallWaiting(Parcel &p, void *response, return 0; } +static void responseSimRefreshV7(Parcel &p, void *response) { + RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response); + p.writeInt32(p_cur->result); + p.writeInt32(p_cur->ef_id); + writeStringToParcel(p, p_cur->aid); + + appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s", + printBuf, + p_cur->result, + p_cur->ef_id, + p_cur->aid); + +} + static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { if (response == NULL && responselen != 0) { RLOGE("responseSimRefresh: invalid response: NULL"); @@ -3076,35 +3350,38 @@ static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { } startResponse; - if (s_callbacks.version == 7) { - RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response); - p.writeInt32(p_cur->result); - p.writeInt32(p_cur->ef_id); - writeStringToParcel(p, p_cur->aid); - - appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s", - printBuf, - p_cur->result, - p_cur->ef_id, - p_cur->aid); - } else { - int *p_cur = ((int *) response); - p.writeInt32(p_cur[0]); - p.writeInt32(p_cur[1]); - writeStringToParcel(p, NULL); + if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) { + if (s_callbacks.version >= 7) { + responseSimRefreshV7(p, response); + } else { + int *p_cur = ((int *) response); + p.writeInt32(p_cur[0]); + p.writeInt32(p_cur[1]); + writeStringToParcel(p, NULL); + + appendPrintBuf("%sresult=%d, ef_id=%d", + printBuf, + p_cur[0], + p_cur[1]); + } + } else { // RIL version >= 13 + if (responselen % sizeof(RIL_SimRefreshResponse_v7) != 0) { + RLOGE("Data structure expected is RIL_SimRefreshResponse_v7"); + if (!isDebuggable()) { + return RIL_ERRNO_INVALID_RESPONSE; + } else { + assert(0); + } + } + responseSimRefreshV7(p, response); - appendPrintBuf("%sresult=%d, ef_id=%d", - printBuf, - p_cur[0], - p_cur[1]); } closeResponse; 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; @@ -3123,23 +3400,12 @@ static int responseCellInfoList(Parcel &p, void *response, size_t responselen) 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); @@ -3149,16 +3415,6 @@ static int responseCellInfoList(Parcel &p, void *response, size_t responselen) 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); @@ -3169,26 +3425,12 @@ static int responseCellInfoList(Parcel &p, void *response, size_t responselen) 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); @@ -3197,26 +3439,12 @@ static int responseCellInfoList(Parcel &p, void *response, size_t responselen) 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); @@ -3226,15 +3454,101 @@ static int responseCellInfoList(Parcel &p, void *response, size_t responselen) 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); @@ -3248,6 +3562,30 @@ static int responseCellInfoList(Parcel &p, void *response, size_t responselen) } 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; } @@ -3459,6 +3797,29 @@ static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatu closeResponse; } +static void responseSimStatusV5(Parcel &p, void *response) { + RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response); + + p.writeInt32(p_cur->card_state); + p.writeInt32(p_cur->universal_pin_state); + p.writeInt32(p_cur->gsm_umts_subscription_app_index); + p.writeInt32(p_cur->cdma_subscription_app_index); + + sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); +} + +static void responseSimStatusV6(Parcel &p, void *response) { + RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response); + + p.writeInt32(p_cur->card_state); + p.writeInt32(p_cur->universal_pin_state); + p.writeInt32(p_cur->gsm_umts_subscription_app_index); + p.writeInt32(p_cur->cdma_subscription_app_index); + p.writeInt32(p_cur->ims_subscription_app_index); + + sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); +} + static int responseSimStatus(Parcel &p, void *response, size_t responselen) { int i; @@ -3467,29 +3828,25 @@ static int responseSimStatus(Parcel &p, void *response, size_t responselen) { return RIL_ERRNO_INVALID_RESPONSE; } - if (responselen == sizeof (RIL_CardStatus_v6)) { - RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response); - - p.writeInt32(p_cur->card_state); - p.writeInt32(p_cur->universal_pin_state); - p.writeInt32(p_cur->gsm_umts_subscription_app_index); - p.writeInt32(p_cur->cdma_subscription_app_index); - p.writeInt32(p_cur->ims_subscription_app_index); - - sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); - } else if (responselen == sizeof (RIL_CardStatus_v5)) { - RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response); - - p.writeInt32(p_cur->card_state); - p.writeInt32(p_cur->universal_pin_state); - p.writeInt32(p_cur->gsm_umts_subscription_app_index); - p.writeInt32(p_cur->cdma_subscription_app_index); - p.writeInt32(-1); - - sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications); - } else { - RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n"); - return RIL_ERRNO_INVALID_RESPONSE; + if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) { + if (responselen == sizeof (RIL_CardStatus_v6)) { + responseSimStatusV6(p, response); + } else if (responselen == sizeof (RIL_CardStatus_v5)) { + responseSimStatusV5(p, response); + } else { + RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n"); + return RIL_ERRNO_INVALID_RESPONSE; + } + } else { // RIL version >= 13 + if (responselen % sizeof(RIL_CardStatus_v6) != 0) { + RLOGE("Data structure expected is RIL_CardStatus_v6"); + if (!isDebuggable()) { + return RIL_ERRNO_INVALID_RESPONSE; + } else { + assert(0); + } + } + responseSimStatusV6(p, response); } return 0; @@ -3628,8 +3985,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; } @@ -3652,8 +4009,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; } @@ -3666,7 +4023,7 @@ static int responseLceData(Parcel &p, void *response, size_t responselen) { p.write((void *)&(p_cur->lce_suspended), 1); startResponse; - appendPrintBuf("LCE info received: capacity %d confidence level %d + appendPrintBuf("LCE info received: capacity %d confidence level %d \ and suspended %d", p_cur->last_hop_capacity_kbps, p_cur->confidence_level, p_cur->lce_suspended); @@ -3681,8 +4038,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; } @@ -3696,7 +4053,7 @@ static int responseActivityData(Parcel &p, void *response, size_t responselen) { p.writeInt32(p_cur->rx_mode_time_ms); startResponse; - appendPrintBuf("Modem activity info received: sleep_mode_time_ms %d idle_mode_time_ms %d + appendPrintBuf("Modem activity info received: sleep_mode_time_ms %d idle_mode_time_ms %d \ tx_mode_time_ms %d %d %d %d %d and rx_mode_time_ms %d", p_cur->sleep_mode_time_ms, p_cur->idle_mode_time_ms, p_cur->tx_mode_time_ms[0], p_cur->tx_mode_time_ms[1], p_cur->tx_mode_time_ms[2], p_cur->tx_mode_time_ms[3], @@ -3706,6 +4063,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 @@ -3852,7 +4281,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; @@ -4009,23 +4438,51 @@ static void debugCallback (int fd, short flags, void *param) { 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]; @@ -4306,11 +4763,7 @@ RIL_register (const RIL_RadioFunctions *callbacks) { callbacks->version, RIL_VERSION_MIN); return; } - if (callbacks->version > RIL_VERSION) { - RLOGE("RIL_register: version %d is too new, max version is %d", - callbacks->version, RIL_VERSION); - return; - } + RLOGE("RIL_register: RIL version %d", callbacks->version); if (s_registerCalled > 0) { @@ -4330,7 +4783,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) @@ -4342,7 +4796,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 @@ -4355,7 +4810,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 @@ -4368,7 +4824,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 @@ -4471,12 +4928,15 @@ 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:; } } } +// 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 */ @@ -4514,8 +4974,15 @@ checkAndDequeueRequestInfo(struct RequestInfo *pRI) { ) { 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; } } @@ -4525,38 +4992,82 @@ checkAndDequeueRequestInfo(struct RequestInfo *pRI) { 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 @@ -4575,7 +5086,14 @@ RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responsel 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(); @@ -4607,15 +5125,54 @@ done: 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); + } } /** @@ -4624,8 +5181,20 @@ releaseWakeLock() { 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(); + } } } @@ -4810,8 +5379,12 @@ void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, 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] @@ -4841,6 +5414,23 @@ void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, 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 @@ -4857,25 +5447,15 @@ 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; + } 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; @@ -4895,7 +5475,12 @@ 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; + + } p_info->p_callback = callback; p_info->userParam = param; @@ -4943,6 +5528,74 @@ failCauseToString(RIL_Errno e) { 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_INVALID_SMS_FORMAT: return "E_INVALID_SMS_FORMAT"; + case RIL_E_ENCODING_ERR: return "E_ENCODING_ERR"; + case RIL_E_INVALID_SMSC_ADDRESS: return "E_INVALID_SMSC_ADDRESS"; + case RIL_E_NO_SUCH_ENTRY: return "E_NO_SUCH_ENTRY"; + case RIL_E_NETWORK_NOT_READY: return "E_NETWORK_NOT_READY"; + case RIL_E_NOT_PROVISIONED: return "E_NOT_PROVISIONED"; + case RIL_E_NO_SUBSCRIPTION: return "E_NO_SUBSCRIPTION"; + case RIL_E_NO_NETWORK_FOUND: return "E_NO_NETWORK_FOUND"; + case RIL_E_DEVICE_IN_USE: return "E_DEVICE_IN_USE"; + case RIL_E_ABORTED: return "E_ABORTED"; + 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 ""; } } @@ -5052,6 +5705,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"; @@ -5096,6 +5750,7 @@ requestToString(int request) { 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"; @@ -5114,6 +5769,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"; @@ -5124,6 +5781,7 @@ 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_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"; @@ -5157,6 +5815,8 @@ requestToString(int request) { 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"; + case RIL_UNSOL_PCO_DATA: return "RIL_UNSOL_PCO_DATA"; default: return ""; } } @@ -5184,6 +5844,18 @@ rilSocketIdToString(RIL_SOCKET_ID socket_id) } } +/* + * Returns true for a debuggable build. + */ +static bool isDebuggable() { + char debuggable[PROP_VALUE_MAX]; + property_get("ro.debuggable", debuggable, "0"); + if (strcmp(debuggable, "1") == 0) { + return true; + } + return false; +} + } /* namespace android */ void rilEventAddWakeup_helper(struct ril_event *ev) {