#include <errno.h>
#include <assert.h>
#include <ctype.h>
-#include <alloca.h>
#include <sys/un.h>
#include <assert.h>
#include <netinet/in.h>
#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
#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
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);
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 decodeVoiceRadioTechnology (RIL_RadioState radioState);
static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
#endif
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
+ if (pRI == NULL) {
+ RLOGE("Memory allocation failed for request %s", requestToString(request));
+ return;
+ }
pRI->local = 1;
pRI->token = 0xffffffff; // token is not used in this context
return 0;
}
+ // Received an Ack for the previous result sent to RIL.java,
+ // so release wakelock and exit
+ if (request == RIL_RESPONSE_ACKNOWLEDGEMENT) {
+ releaseWakeLock();
+ return 0;
+ }
+
if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
Parcel pErr;
RLOGE("unsupported request code %d token %d", request, token);
return 0;
}
- // Received an Ack for the previous result sent to RIL.java,
- // so release wakelock and exit
- if (request == RIL_RESPONSE_ACKNOWLEDGEMENT) {
- releaseWakeLock();
+ pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
+ if (pRI == NULL) {
+ RLOGE("Memory allocation failed for request %s", requestToString(request));
return 0;
}
-
- pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
-
pRI->token = token;
pRI->pCI = &(s_commands[request]);
pRI->socket_id = socket_id;
startRequest;
if (countStrings == 0) {
// just some non-null pointer
- pStrings = (char **)alloca(sizeof(char *));
+ pStrings = (char **)calloc(1, sizeof(char *));
+ if (pStrings == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ closeRequest;
+ return;
+ }
+
datalen = 0;
- } else if (((int)countStrings) == -1) {
+ } else if (countStrings < 0) {
pStrings = NULL;
datalen = 0;
} else {
datalen = sizeof(char *) * countStrings;
- pStrings = (char **)alloca(datalen);
+ pStrings = (char **)calloc(countStrings, sizeof(char *));
+ if (pStrings == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ closeRequest;
+ return;
+ }
for (int i = 0 ; i < countStrings ; i++) {
pStrings[i] = strdupReadString(p);
#ifdef MEMSET_FREED
memset(pStrings, 0, datalen);
#endif
+ free(pStrings);
}
return;
status = p.readInt32 (&count);
- if (status != NO_ERROR || count == 0) {
+ if (status != NO_ERROR || count <= 0) {
goto invalid;
}
datalen = sizeof(int) * count;
- pInts = (int *)alloca(datalen);
+ pInts = (int *)calloc(count, sizeof(int));
+ if (pInts == NULL) {
+ RLOGE("Memory allocation failed for request %s", requestToString(pRI->pCI->requestNumber));
+ return;
+ }
startRequest;
for (int i = 0 ; i < count ; i++) {
appendPrintBuf("%s%d,", printBuf, t);
if (status != NO_ERROR) {
+ free(pInts);
goto invalid;
}
}
#ifdef MEMSET_FREED
memset(pInts, 0, datalen);
#endif
-
+ free(pInts);
return;
invalid:
invalidCommandBlock(pRI);
(int)rism.tech, (int)rism.retry, rism.messageRef);
if (countStrings == 0) {
// just some non-null pointer
- pStrings = (char **)alloca(sizeof(char *));
+ pStrings = (char **)calloc(1, sizeof(char *));
+ if (pStrings == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ closeRequest;
+ return;
+ }
+
datalen = 0;
- } else if (((int)countStrings) == -1) {
+ } else if (countStrings < 0) {
pStrings = NULL;
datalen = 0;
} else {
+ if (countStrings > (INT_MAX/sizeof(char *))) {
+ RLOGE("Invalid value of countStrings: \n");
+ closeRequest;
+ return;
+ }
datalen = sizeof(char *) * countStrings;
- pStrings = (char **)alloca(datalen);
+ pStrings = (char **)calloc(countStrings, sizeof(char *));
+ if (pStrings == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ closeRequest;
+ return;
+ }
for (int i = 0 ; i < countStrings ; i++) {
pStrings[i] = strdupReadString(p);
#ifdef MEMSET_FREED
memset(pStrings, 0, datalen);
#endif
+ free(pStrings);
}
#ifdef MEMSET_FREED
uint8_t uct;
status_t status;
int32_t digitCount;
+ int32_t digitLimit;
memset(&rcsw, 0, sizeof(rcsw));
status = p.read(&uct,sizeof(uct));
rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct,sizeof(uct));
rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
}
status = p.read(&uct,sizeof(uct));
rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct,sizeof(uct));
rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
}
status = p.readInt32(&t);
rcsw.message.uBearerDataLen = (int) t;
- for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
+ digitLimit = MIN((rcsw.message.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
+
+ for(digitCount = 0 ; digitCount < digitLimit; digitCount ++) {
status = p.read(&uct, sizeof(uct));
rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
}
int32_t num;
status = p.readInt32(&num);
- if (status != NO_ERROR) {
+ if (status != NO_ERROR || num < 0) {
goto invalid;
}
{
- RIL_DataProfileInfo dataProfiles[num];
- RIL_DataProfileInfo *dataProfilePtrs[num];
+ RIL_DataProfileInfo *dataProfiles =
+ (RIL_DataProfileInfo *)calloc(num, sizeof(RIL_DataProfileInfo));
+ if (dataProfiles == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ return;
+ }
+ RIL_DataProfileInfo **dataProfilePtrs =
+ (RIL_DataProfileInfo **)calloc(num, sizeof(RIL_DataProfileInfo *));
+ if (dataProfilePtrs == NULL) {
+ RLOGE("Memory allocation failed for request %s",
+ requestToString(pRI->pCI->requestNumber));
+ free(dataProfiles);
+ return;
+ }
startRequest;
for (int i = 0 ; i < num ; i++ ) {
printRequest(pRI->token, pRI->pCI->requestNumber);
if (status != NO_ERROR) {
+ free(dataProfiles);
+ free(dataProfilePtrs);
goto invalid;
}
CALL_ONREQUEST(pRI->pCI->requestNumber,
memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo));
memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *));
#endif
+ free(dataProfiles);
+ free(dataProfilePtrs);
}
return;
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 < 13) {
+ RLOGE("Unsuppoted RIL version %d, min version expected %d",
+ s_callbacks.version, 13);
+ 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;
+
+ for (int32_t i = 0; i < cr.len_allowed_carriers; i++) {
+ RIL_Carrier *p_cr = allowed_carriers + i;
+ p_cr->mcc = p.readCString();
+ p_cr->mnc = p.readCString();
+ status = p.readInt32(&t);
+ p_cr->match_type = static_cast<RIL_CarrierMatchType>(t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ p_cr->match_data = p.readCString();
+ }
+
+ for (int32_t i = 0; i < cr.len_excluded_carriers; i++) {
+ RIL_Carrier *p_cr = excluded_carriers + i;
+ p_cr->mcc = p.readCString();
+ p_cr->mnc = p.readCString();
+ status = p.readInt32(&t);
+ p_cr->match_type = static_cast<RIL_CarrierMatchType>(t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ p_cr->match_data = p.readCString();
+ }
+
+ startRequest;
+ appendPrintBuf("%s [len_allowed_carriers:%d, len_excluded_carriers:%d]",
+ printBuf, cr.len_allowed_carriers, cr.len_excluded_carriers);
+
+ 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;
CDMA_ALPHA_INFO_BUFFER_LENGTH);
return RIL_ERRNO_INVALID_RESPONSE;
}
- string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
- * sizeof(char) );
+ string8 = (char*) calloc(infoRec->rec.display.alpha_len + 1, sizeof(char));
+ if (string8 == NULL) {
+ RLOGE("Memory allocation failed for responseCdmaInformationRecords");
+ closeRequest;
+ return RIL_ERRNO_NO_MEMORY;
+ }
for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
string8[i] = infoRec->rec.display.alpha_buf[i];
}
CDMA_NUMBER_INFO_BUFFER_LENGTH);
return RIL_ERRNO_INVALID_RESPONSE;
}
- string8 = (char*) malloc((infoRec->rec.number.len + 1)
- * sizeof(char) );
+ string8 = (char*) calloc(infoRec->rec.number.len + 1, sizeof(char));
+ if (string8 == NULL) {
+ RLOGE("Memory allocation failed for responseCdmaInformationRecords");
+ closeRequest;
+ return RIL_ERRNO_NO_MEMORY;
+ }
for (int i = 0 ; i < infoRec->rec.number.len; i++) {
string8[i] = infoRec->rec.number.buf[i];
}
CDMA_NUMBER_INFO_BUFFER_LENGTH);
return RIL_ERRNO_INVALID_RESPONSE;
}
- string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
- .len + 1) * sizeof(char) );
+ string8 = (char*) calloc(infoRec->rec.redir.redirectingNumber.len + 1,
+ sizeof(char));
+ if (string8 == NULL) {
+ RLOGE("Memory allocation failed for responseCdmaInformationRecords");
+ closeRequest;
+ return RIL_ERRNO_NO_MEMORY;
+ }
for (int i = 0;
i < infoRec->rec.redir.redirectingNumber.len;
i++) {
startResponse;
int i;
for (i = 0; i < num; i++) {
- appendPrintBuf("%s[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", printBuf, i,
- p_cur->cellInfoType, p_cur->registered, p_cur->timeStampType, p_cur->timeStamp);
p.writeInt32((int)p_cur->cellInfoType);
p.writeInt32(p_cur->registered);
p.writeInt32(p_cur->timeStampType);
p.writeInt64(p_cur->timeStamp);
switch(p_cur->cellInfoType) {
case RIL_CELL_INFO_TYPE_GSM: {
- appendPrintBuf("%s GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,", printBuf,
- p_cur->CellInfo.gsm.cellIdentityGsm.mcc,
- p_cur->CellInfo.gsm.cellIdentityGsm.mnc,
- p_cur->CellInfo.gsm.cellIdentityGsm.lac,
- p_cur->CellInfo.gsm.cellIdentityGsm.cid);
- appendPrintBuf("%s gsmSS: ss=%d,ber=%d],", printBuf,
- p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
- p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
-
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac);
break;
}
case RIL_CELL_INFO_TYPE_WCDMA: {
- appendPrintBuf("%s WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,", printBuf,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.lac,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.cid,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.psc);
- appendPrintBuf("%s wcdmaSS: ss=%d,ber=%d],", printBuf,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
-
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac);
break;
}
case RIL_CELL_INFO_TYPE_CDMA: {
- appendPrintBuf("%s CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d", printBuf,
- p_cur->CellInfo.cdma.cellIdentityCdma.networkId,
- p_cur->CellInfo.cdma.cellIdentityCdma.systemId,
- p_cur->CellInfo.cdma.cellIdentityCdma.basestationId,
- p_cur->CellInfo.cdma.cellIdentityCdma.longitude,
- p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
-
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.networkId);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.systemId);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.basestationId);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.longitude);
p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
- appendPrintBuf("%s cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d", printBuf,
- p_cur->CellInfo.cdma.signalStrengthCdma.dbm,
- p_cur->CellInfo.cdma.signalStrengthCdma.ecio,
- p_cur->CellInfo.cdma.signalStrengthEvdo.dbm,
- p_cur->CellInfo.cdma.signalStrengthEvdo.ecio,
- p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
-
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm);
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio);
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm);
break;
}
case RIL_CELL_INFO_TYPE_LTE: {
- appendPrintBuf("%s LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d", printBuf,
- p_cur->CellInfo.lte.cellIdentityLte.mcc,
- p_cur->CellInfo.lte.cellIdentityLte.mnc,
- p_cur->CellInfo.lte.cellIdentityLte.ci,
- p_cur->CellInfo.lte.cellIdentityLte.pci,
- p_cur->CellInfo.lte.cellIdentityLte.tac);
-
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mcc);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mnc);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.ci);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.pci);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.tac);
- appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf,
- p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
- p_cur->CellInfo.lte.signalStrengthLte.rsrp,
- p_cur->CellInfo.lte.signalStrengthLte.rsrq,
- p_cur->CellInfo.lte.signalStrengthLte.rssnr,
- p_cur->CellInfo.lte.signalStrengthLte.cqi,
- p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq);
break;
}
case RIL_CELL_INFO_TYPE_TD_SCDMA: {
- appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
- appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf,
- p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
-
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
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);
- RLOGE("[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", 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,arfcn=%d,bsic=%x", 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,
- p_cur->CellInfo.gsm.cellIdentityGsm.arfcn,
- p_cur->CellInfo.gsm.cellIdentityGsm.bsic);
- RLOGE("GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,arfcn=%d,bsic=%x",
- p_cur->CellInfo.gsm.cellIdentityGsm.mcc,
- p_cur->CellInfo.gsm.cellIdentityGsm.mnc,
- p_cur->CellInfo.gsm.cellIdentityGsm.lac,
- p_cur->CellInfo.gsm.cellIdentityGsm.cid,
- p_cur->CellInfo.gsm.cellIdentityGsm.arfcn,
- p_cur->CellInfo.gsm.cellIdentityGsm.bsic);
- RLOGE("gsmSS: ss=%d,ber=%d, ta=%d],",
- p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
- p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate,
- p_cur->CellInfo.gsm.signalStrengthGsm.timingAdvance);
- appendPrintBuf("%s gsmSS: ss=%d,ber=%d, ta=%d],", printBuf,
- p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
- p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate,
- p_cur->CellInfo.gsm.signalStrengthGsm.timingAdvance);
-
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc);
p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac);
break;
}
case RIL_CELL_INFO_TYPE_WCDMA: {
- RLOGE("WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,uarfcn=%d",
- 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,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.uarfcn);
- RLOGE("wcdmaSS: ss=%d,ber=%d],",
- p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
- appendPrintBuf("%s WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,uarfcn=%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,
- p_cur->CellInfo.wcdma.cellIdentityWcdma.uarfcn);
- appendPrintBuf("%s wcdmaSS: ss=%d,ber=%d],", printBuf,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
- p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
-
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc);
p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac);
break;
}
case RIL_CELL_INFO_TYPE_CDMA: {
- RLOGE("CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d",
- 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);
-
- 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);
- RLOGE("cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d",
- 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);
-
- appendPrintBuf("%s cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d", printBuf,
- p_cur->CellInfo.cdma.signalStrengthCdma.dbm,
- p_cur->CellInfo.cdma.signalStrengthCdma.ecio,
- p_cur->CellInfo.cdma.signalStrengthEvdo.dbm,
- p_cur->CellInfo.cdma.signalStrengthEvdo.ecio,
- p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
-
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm);
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio);
p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm);
break;
}
case RIL_CELL_INFO_TYPE_LTE: {
- RLOGE("LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d,earfcn=%d",
- 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_cur->CellInfo.lte.cellIdentityLte.earfcn);
-
- appendPrintBuf("%s LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d,earfcn=%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_cur->CellInfo.lte.cellIdentityLte.earfcn);
-
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.tac);
p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.earfcn);
- RLOGE("lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d",
- 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);
- appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf,
- p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
- p_cur->CellInfo.lte.signalStrengthLte.rsrp,
- p_cur->CellInfo.lte.signalStrengthLte.rsrq,
- p_cur->CellInfo.lte.signalStrengthLte.rssnr,
- p_cur->CellInfo.lte.signalStrengthLte.cqi,
- p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp);
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq);
break;
}
case RIL_CELL_INFO_TYPE_TD_SCDMA: {
- appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid,
- p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
- appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf,
- p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
-
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
p.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);
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],
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 %d expecting len: %d",
+ sizeof(RIL_CarrierRestrictions), responselen);
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ RIL_CarrierRestrictions *p_cr = (RIL_CarrierRestrictions *)response;
+ p.writeUint32(p_cr->len_allowed_carriers);
+ p.writeUint32(p_cr->len_excluded_carriers);
+ for(uint_t i = 0; i < p_cr->len_allowed_carriers; i++) {
+ RIL_Carrier *carrier = p_cr->allowed_carriers + i;
+ p.writeCString(carrier->mcc);
+ p.writeCString(carrier->mnc);
+ p.writeInt32(carrier->match_type);
+ p.writeCString(carrier->match_data);
+ }
+ for(uint_t i = 0; i < p_cr->len_excluded_carriers; i++) {
+ RIL_Carrier *carrier = p_cr->excluded_carriers + i;
+ p.writeCString(carrier->mcc);
+ p.writeCString(carrier->mnc);
+ p.writeInt32(carrier->match_type);
+ p.writeCString(carrier->match_data);
+ }
+
+ startResponse;
+ appendPrintBuf("CarrierRestrictions received: len_allowed_carriers %d len_excluded_carriers %d",
+ p_cr->len_allowed_carriers,p_cr->len_excluded_carriers);
+ 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
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];
ret = pthread_mutex_lock(&s_wakeLockCountMutex);
assert(ret == 0);
acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
- s_wakelock_count++;
- 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);
+ 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 {
appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
Parcel p;
- p.writeInt32 (RESPONSE_UNSOLICITED);
+ if (s_callbacks.version >= 13
+ && s_unsolResponses[unsolResponseIndex].wakeType == WAKE_PARTIAL) {
+ p.writeInt32 (RESPONSE_UNSOLICITED_ACK_EXP);
+ } else {
+ p.writeInt32 (RESPONSE_UNSOLICITED);
+ }
p.writeInt32 (unsolResponse);
ret = s_unsolResponses[unsolResponseIndex]
break;
}
+ if (s_callbacks.version < 13) {
+ if (shouldScheduleTimeout) {
+ UserCallbackInfo *p_info = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
+ &TIMEVAL_WAKE_TIMEOUT);
+
+ if (p_info == NULL) {
+ goto error_exit;
+ } else {
+ // Cancel the previous request
+ if (s_last_wake_timeout_info != NULL) {
+ s_last_wake_timeout_info->userParam = (void *)1;
+ }
+ s_last_wake_timeout_info = p_info;
+ }
+ }
+ }
+
#if VDBG
RLOGI("%s UNSOLICITED: %s length:%d", rilSocketIdToString(soc_id), requestToString(unsolResponse), p.dataSize());
#endif
s_lastNITZTimeData = NULL;
}
- s_lastNITZTimeData = malloc(p.dataSize());
+ s_lastNITZTimeData = calloc(p.dataSize(), 1);
+ if (s_lastNITZTimeData == NULL) {
+ RLOGE("Memory allocation failed in RIL_onUnsolicitedResponse");
+ goto error_exit;
+ }
s_lastNITZTimeDataSize = p.dataSize();
memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
}
- if (s_callbacks.version < 13) {
- if (shouldScheduleTimeout) {
- // Cancel the previous request
- if (s_last_wake_timeout_info != NULL) {
- s_last_wake_timeout_info->userParam = (void *)1;
- }
-
- s_last_wake_timeout_info
- = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
- &TIMEVAL_WAKE_TIMEOUT);
- }
- }
-
// Normal exit
return;
struct timeval myRelativeTime;
UserCallbackInfo *p_info;
- p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
+ p_info = (UserCallbackInfo *) calloc(1, sizeof(UserCallbackInfo));
+ if (p_info == NULL) {
+ RLOGE("Memory allocation failed in internalRequestTimedCallback");
+ return p_info;
+
+ }
p_info->p_callback = callback;
p_info->userParam = param;
case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
#endif
+ case RIL_E_FDN_CHECK_FAILURE: return "E_FDN_CHECK_FAILURE";
+ case RIL_E_MISSING_RESOURCE: return "E_MISSING_RESOURCE";
+ case RIL_E_NO_SUCH_ELEMENT: return "E_NO_SUCH_ELEMENT";
+ case RIL_E_DIAL_MODIFIED_TO_USSD: return "E_DIAL_MODIFIED_TO_USSD";
+ case RIL_E_DIAL_MODIFIED_TO_SS: return "E_DIAL_MODIFIED_TO_SS";
+ case RIL_E_DIAL_MODIFIED_TO_DIAL: return "E_DIAL_MODIFIED_TO_DIAL";
+ case RIL_E_USSD_MODIFIED_TO_DIAL: return "E_USSD_MODIFIED_TO_DIAL";
+ case RIL_E_USSD_MODIFIED_TO_SS: return "E_USSD_MODIFIED_TO_SS";
+ case RIL_E_USSD_MODIFIED_TO_USSD: return "E_USSD_MODIFIED_TO_USSD";
+ case RIL_E_SS_MODIFIED_TO_DIAL: return "E_SS_MODIFIED_TO_DIAL";
+ case RIL_E_SS_MODIFIED_TO_USSD: return "E_SS_MODIFIED_TO_USSD";
+ case RIL_E_SUBSCRIPTION_NOT_SUPPORTED: return "E_SUBSCRIPTION_NOT_SUPPORTED";
+ case RIL_E_SS_MODIFIED_TO_SS: return "E_SS_MODIFIED_TO_SS";
+ case RIL_E_LCE_NOT_SUPPORTED: return "E_LCE_NOT_SUPPORTED";
+ case RIL_E_NO_MEMORY: return "E_NO_MEMORY";
+ case RIL_E_INTERNAL_ERR: return "E_INTERNAL_ERR";
+ case RIL_E_SYSTEM_ERR: return "E_SYSTEM_ERR";
+ case RIL_E_MODEM_ERR: return "E_MODEM_ERR";
+ case RIL_E_INVALID_STATE: return "E_INVALID_STATE";
+ case RIL_E_NO_RESOURCES: return "E_NO_RESOURCES";
+ case RIL_E_SIM_ERR: return "E_SIM_ERR";
+ case RIL_E_INVALID_ARGUMENTS: return "E_INVALID_ARGUMENTS";
+ case RIL_E_INVALID_SIM_STATE: return "E_INVALID_SIM_STATE";
+ case RIL_E_INVALID_MODEM_STATE: return "E_INVALID_MODEM_STATE";
+ case RIL_E_INVALID_CALL_ID: return "E_INVALID_CALL_ID";
+ case RIL_E_NO_SMS_TO_ACK: return "E_NO_SMS_TO_ACK";
+ case RIL_E_NETWORK_ERR: return "E_NETWORK_ERR";
+ case RIL_E_REQUEST_RATE_LIMITED: return "E_REQUEST_RATE_LIMITED";
+ case RIL_E_SIM_BUSY: return "E_SIM_BUSY";
+ case RIL_E_SIM_FULL: return "E_SIM_FULL";
+ case RIL_E_NETWORK_REJECT: return "E_NETWORK_REJECT";
+ case RIL_E_OPERATION_NOT_ALLOWED: return "E_OPERATION_NOT_ALLOWED";
+ case RIL_E_EMPTY_RECORD: "E_EMPTY_RECORD";
+ case RIL_E_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 "<unknown error>";
}
}
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";
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";