X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=libril%2Fril.cpp;h=08035636187b87553eede3eda6faad7b5be9fdb8;hb=ab379831bc;hp=03f3ab5292b381ea0fba29541954bf7043512b9f;hpb=1dca1159a27626dc92e1a6b8ff51c4114b1558cb;p=android-x86%2Fhardware-ril.git diff --git a/libril/ril.cpp b/libril/ril.cpp index 03f3ab5..0803563 100644 --- a/libril/ril.cpp +++ b/libril/ril.cpp @@ -42,7 +42,6 @@ #include #include #include -#include #include #include #include @@ -51,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" @@ -85,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 @@ -144,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 { @@ -176,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; @@ -183,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) @@ -272,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); @@ -304,10 +315,15 @@ 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); @@ -450,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 @@ -516,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); @@ -528,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]); @@ -611,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); @@ -643,6 +686,7 @@ dispatchStrings (Parcel &p, RequestInfo *pRI) { #ifdef MEMSET_FREED memset(pStrings, 0, datalen); #endif + free(pStrings); } return; @@ -661,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++) { @@ -677,6 +725,7 @@ dispatchInts (Parcel &p, RequestInfo *pRI) { appendPrintBuf("%s%d,", printBuf, t); if (status != NO_ERROR) { + free(pInts); goto invalid; } } @@ -690,7 +739,7 @@ dispatchInts (Parcel &p, RequestInfo *pRI) { #ifdef MEMSET_FREED memset(pInts, 0, datalen); #endif - + free(pInts); return; invalid: invalidCommandBlock(pRI); @@ -1270,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); @@ -1305,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 @@ -1524,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)); @@ -1554,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; } @@ -1568,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; } @@ -1576,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; } @@ -1917,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++ ) { @@ -1965,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, @@ -1976,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; @@ -2046,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; @@ -2574,7 +2765,7 @@ static int responseDataCallList(Parcel &p, void *response, size_t responselen) } 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()) { @@ -2793,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]; } @@ -2813,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]; } @@ -2850,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++) { @@ -2967,9 +3171,10 @@ static int responseRilSignalStrength(Parcel &p, return RIL_ERRNO_INVALID_RESPONSE; } + RIL_SignalStrength_v10 *p_cur; if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) { if (responselen >= sizeof (RIL_SignalStrength_v5)) { - RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response); + p_cur = ((RIL_SignalStrength_v10 *) response); responseRilSignalStrengthV5(p, p_cur); @@ -2992,7 +3197,7 @@ static int responseRilSignalStrength(Parcel &p, 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()) { @@ -3001,7 +3206,7 @@ static int responseRilSignalStrength(Parcel &p, assert(0); } } - RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response); + p_cur = ((RIL_SignalStrength_v10 *) response); responseRilSignalStrengthV10(p, p_cur); } startResponse; @@ -3092,7 +3297,7 @@ static int responseCdmaCallWaiting(Parcel &p, void *response, 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()) { @@ -3146,7 +3351,7 @@ static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { 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); @@ -3159,7 +3364,7 @@ static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { 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()) { @@ -3176,8 +3381,7 @@ static int responseSimRefresh(Parcel &p, void *response, size_t responselen) { 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; @@ -3196,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); @@ -3222,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); @@ -3242,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); @@ -3270,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); @@ -3299,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); @@ -3321,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; } @@ -3572,7 +3837,7 @@ static int responseSimStatus(Parcel &p, void *response, size_t responselen) { 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()) { @@ -3720,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; } @@ -3744,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; } @@ -3773,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; } @@ -3798,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 @@ -3944,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; @@ -4082,12 +4419,12 @@ static void debugCallback (int fd, short flags, void *param) { int data; unsigned int qxdm_data[6]; const char *deactData[1] = {"1"}; - char *actData[1]; RIL_Dial dialData; int hangupData[1] = {1}; int number; char **args; RIL_SOCKET_ID socket_id = RIL_SOCKET_1; + int MAX_DIAL_ADDRESS = 128; int sim_id = 0; RLOGI("debugCallback for socket %s", rilSocketIdToString(socket_id)); @@ -4101,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]; @@ -4206,12 +4571,6 @@ static void debugCallback (int fd, short flags, void *param) { // Set network selection automatic. issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0, socket_id); break; - case 6: - RLOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]); - actData[0] = args[1]; - issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData, - sizeof(actData), socket_id); - break; case 7: RLOGI("Debug port: Deactivate Data Call"); issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData, @@ -4220,6 +4579,12 @@ static void debugCallback (int fd, short flags, void *param) { case 8: RLOGI("Debug port: Dial Call"); dialData.clir = 0; + if (strlen(args[1]) > MAX_DIAL_ADDRESS) { + RLOGE("Debug port: Error calling Dial"); + freeDebugCallbackArgs(number, args); + close(acceptFD); + return; + } dialData.address = args[1]; issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData), socket_id); break; @@ -4418,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) @@ -4430,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 @@ -4443,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 @@ -4456,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 @@ -4559,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 */ @@ -4602,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; } } @@ -4613,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 @@ -4663,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(); @@ -4695,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); + } } /** @@ -4712,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(); + } } } @@ -4898,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] @@ -4929,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 @@ -4945,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; @@ -4983,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; @@ -5031,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 ""; } } @@ -5140,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"; @@ -5184,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"; @@ -5202,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"; @@ -5212,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"; @@ -5245,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 ""; } }