#include <telephony/ril_cdma_sms.h>
#include <cutils/sockets.h>
#include <cutils/jstring.h>
-#include "record_stream.h"
+#include <telephony/record_stream.h>
#include <utils/Log.h>
#include <utils/SystemClock.h>
#include <pthread.h>
#define PHONE_PROCESS "radio"
#define SOCKET_NAME_RIL "rild"
+#define SOCKET2_NAME_RIL "rild2"
+#define SOCKET3_NAME_RIL "rild3"
+#define SOCKET4_NAME_RIL "rild4"
+
#define SOCKET_NAME_RIL_DEBUG "rild-debug"
#define ANDROID_WAKE_LOCK_NAME "radio-interface"
struct RequestInfo *p_next;
char cancelled;
char local; // responses to local commands do not go back to command process
+ RIL_SOCKET_ID socket_id;
} RequestInfo;
typedef struct UserCallbackInfo {
struct UserCallbackInfo *p_next;
} UserCallbackInfo;
+typedef struct SocketListenParam {
+ RIL_SOCKET_ID socket_id;
+ int fdListen;
+ int fdCommand;
+ char* processName;
+ struct ril_event* commands_event;
+ struct ril_event* listen_event;
+ void (*processCommandsCallback)(int fd, short flags, void *param);
+ RecordStream *p_rs;
+} SocketListenParam;
+
+extern "C" const char * requestToString(int request);
+extern "C" const char * failCauseToString(RIL_Errno);
+extern "C" const char * callStateToString(RIL_CallState);
+extern "C" const char * radioStateToString(RIL_RadioState);
+extern "C" const char * rilSocketIdToString(RIL_SOCKET_ID socket_id);
+extern "C"
+char rild[MAX_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL;
/*******************************************************************/
RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
static pthread_t s_tid_reader;
static int s_started = 0;
-static int s_fdListen = -1;
-static int s_fdCommand = -1;
static int s_fdDebug = -1;
+static int s_fdDebug_socket2 = -1;
static int s_fdWakeupRead;
static int s_fdWakeupWrite;
static struct ril_event s_commands_event;
static struct ril_event s_wakeupfd_event;
static struct ril_event s_listen_event;
+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 RequestInfo *s_pendingRequests = NULL;
+
+#if (SIM_COUNT >= 2)
+static struct ril_event s_commands_event_socket2;
+static struct ril_event s_listen_event_socket2;
+static SocketListenParam s_ril_param_socket2;
+
+static pthread_mutex_t s_pendingRequestsMutex_socket2 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex_socket2 = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests_socket2 = NULL;
+#endif
+
+#if (SIM_COUNT >= 3)
+static struct ril_event s_commands_event_socket3;
+static struct ril_event s_listen_event_socket3;
+static SocketListenParam s_ril_param_socket3;
+
+static pthread_mutex_t s_pendingRequestsMutex_socket3 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex_socket3 = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests_socket3 = NULL;
+#endif
+
+#if (SIM_COUNT >= 4)
+static struct ril_event s_commands_event_socket4;
+static struct ril_event s_listen_event_socket4;
+static SocketListenParam s_ril_param_socket4;
+
+static pthread_mutex_t s_pendingRequestsMutex_socket4 = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t s_writeMutex_socket4 = PTHREAD_MUTEX_INITIALIZER;
+static RequestInfo *s_pendingRequests_socket4 = NULL;
+#endif
+
static struct ril_event s_wake_timeout_event;
static struct ril_event s_debug_event;
static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0};
-static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
+
static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
-static RequestInfo *s_pendingRequests = NULL;
-
static RequestInfo *s_toDispatchHead = NULL;
static RequestInfo *s_toDispatchTail = NULL;
#endif
/*******************************************************************/
+static int sendResponse (Parcel &p, RIL_SOCKET_ID socket_id);
static void dispatchVoid (Parcel& p, RequestInfo *pRI);
static void dispatchString (Parcel& p, RequestInfo *pRI);
static void dispatchInts (Parcel& p, RequestInfo *pRI);
static void dispatchDial (Parcel& p, RequestInfo *pRI);
static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI);
+static void dispatchSIM_APDU (Parcel& p, RequestInfo *pRI);
static void dispatchCallForward(Parcel& p, RequestInfo *pRI);
static void dispatchRaw(Parcel& p, RequestInfo *pRI);
static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI);
static void dispatchCdmaSubscriptionSource (Parcel& p, RequestInfo *pRI);
static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI);
+static void dispatchImsSms(Parcel &p, RequestInfo *pRI);
+static void dispatchImsCdmaSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef);
+static void dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef);
static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI);
static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI);
static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI);
static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI);
+static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI);
+static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI);
+static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI);
+static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI);
+static void dispatchDataProfile(Parcel &p, RequestInfo *pRI);
static int responseInts(Parcel &p, void *response, size_t responselen);
static int responseStrings(Parcel &p, void *response, size_t responselen);
static int responseString(Parcel &p, void *response, size_t responselen);
static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen);
static int responseSimRefresh(Parcel &p, void *response, size_t responselen);
static int responseCellInfoList(Parcel &p, void *response, size_t responselen);
+static int responseHardwareConfig(Parcel &p, void *response, size_t responselen);
+static int responseDcRtInfo(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);
-extern "C" const char * requestToString(int request);
-extern "C" const char * failCauseToString(RIL_Errno);
-extern "C" const char * callStateToString(RIL_CallState);
-extern "C" const char * radioStateToString(RIL_RadioState);
-
#ifdef RIL_SHLIB
+#if defined(ANDROID_MULTI_SIM)
+extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
+ size_t datalen, RIL_SOCKET_ID socket_id);
+#else
extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
size_t datalen);
#endif
+#endif
+
+#if defined(ANDROID_MULTI_SIM)
+#define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c), (d))
+#define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d), (e))
+#define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest(a)
+#else
+#define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c))
+#define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d))
+#define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest()
+#endif
static UserCallbackInfo * internalRequestTimedCallback
(RIL_TimedCallback callback, void *param,
*/
int simRuimStatus = -1;
+static char * RIL_getRilSocketName() {
+ return rild;
+}
+
+extern "C"
+void RIL_setRilSocketName(char * s) {
+ strncpy(rild, s, MAX_SOCKET_NAME_LENGTH);
+}
+
static char *
strdupReadString(Parcel &p) {
size_t stringlen;
* is not sent back up to the command process
*/
static void
-issueLocalRequest(int request, void *data, int len) {
+issueLocalRequest(int request, void *data, int len, RIL_SOCKET_ID socket_id) {
RequestInfo *pRI;
int ret;
+ /* Hook for current context */
+ /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo** pendingRequestsHook = &s_pendingRequests;
+
+#if (SIM_COUNT == 2)
+ if (socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#endif
pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
pRI->local = 1;
pRI->token = 0xffffffff; // token is not used in this context
pRI->pCI = &(s_commands[request]);
+ pRI->socket_id = socket_id;
- ret = pthread_mutex_lock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
- pRI->p_next = s_pendingRequests;
- s_pendingRequests = pRI;
+ pRI->p_next = *pendingRequestsHook;
+ *pendingRequestsHook = pRI;
- ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_unlock(pendingRequestsMutexHook);
assert (ret == 0);
RLOGD("C[locl]> %s", requestToString(request));
- s_callbacks.onRequest(request, data, len, pRI);
+ CALL_ONREQUEST(request, data, len, pRI, pRI->socket_id);
}
static int
-processCommandBuffer(void *buffer, size_t buflen) {
+processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) {
Parcel p;
status_t status;
int32_t request;
int32_t token;
RequestInfo *pRI;
int ret;
+ /* Hook for current context */
+ /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo** pendingRequestsHook = &s_pendingRequests;
p.setData((uint8_t *) buffer, buflen);
status = p.readInt32(&request);
status = p.readInt32 (&token);
+ RLOGD("SOCKET %s REQUEST: %s length:%d", rilSocketIdToString(socket_id), requestToString(request), buflen);
+
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ else if (socket_id == RIL_SOCKET_3) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
+ pendingRequestsHook = &s_pendingRequests_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ else if (socket_id == RIL_SOCKET_4) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
+ pendingRequestsHook = &s_pendingRequests_socket4;
+ }
+#endif
+#endif
+
if (status != NO_ERROR) {
RLOGE("invalid request block");
return 0;
}
if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
+ Parcel pErr;
RLOGE("unsupported request code %d token %d", request, token);
// FIXME this should perhaps return a response
+ pErr.writeInt32 (RESPONSE_SOLICITED);
+ pErr.writeInt32 (token);
+ pErr.writeInt32 (RIL_E_GENERIC_FAILURE);
+
+ sendResponse(pErr, socket_id);
return 0;
}
pRI->token = token;
pRI->pCI = &(s_commands[request]);
+ pRI->socket_id = socket_id;
- ret = pthread_mutex_lock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
- pRI->p_next = s_pendingRequests;
- s_pendingRequests = pRI;
+ pRI->p_next = *pendingRequestsHook;
+ *pendingRequestsHook = pRI;
- ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_unlock(pendingRequestsMutexHook);
assert (ret == 0);
/* sLastDispatchedToken = token; */
dispatchVoid (Parcel& p, RequestInfo *pRI) {
clearPrintBuf;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, NULL, 0, pRI, pRI->socket_id);
}
/** Callee expects const char * */
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, string8,
- sizeof(char *), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, string8,
+ sizeof(char *), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString(string8);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, pStrings, datalen, pRI, pRI->socket_id);
if (pStrings != NULL) {
for (int i = 0 ; i < countStrings ; i++) {
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts),
- datalen, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<int *>(pInts),
+ datalen, pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(pInts, 0, datalen);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &args, sizeof(args), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString (args.pdu);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString (dial.address);
}
size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, size, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &simIO, size, pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString (simIO.v6.path);
}
/**
+ * Callee expects const RIL_SIM_APDU *
+ * Payload is:
+ * int32_t sessionid
+ * int32_t cla
+ * int32_t instruction
+ * int32_t p1, p2, p3
+ * String data
+ */
+static void
+dispatchSIM_APDU (Parcel &p, RequestInfo *pRI) {
+ int32_t t;
+ status_t status;
+ RIL_SIM_APDU apdu;
+
+ memset (&apdu, 0, sizeof(RIL_SIM_APDU));
+
+ // Note we only check status at the end. Any single failure leads to
+ // subsequent reads filing.
+ status = p.readInt32(&t);
+ apdu.sessionid = (int)t;
+
+ status = p.readInt32(&t);
+ apdu.cla = (int)t;
+
+ status = p.readInt32(&t);
+ apdu.instruction = (int)t;
+
+ status = p.readInt32(&t);
+ apdu.p1 = (int)t;
+
+ status = p.readInt32(&t);
+ apdu.p2 = (int)t;
+
+ status = p.readInt32(&t);
+ apdu.p3 = (int)t;
+
+ apdu.data = strdupReadString(p);
+
+ startRequest;
+ appendPrintBuf("%ssessionid=%d,cla=%d,ins=%d,p1=%d,p2=%d,p3=%d,data=%s",
+ printBuf, apdu.sessionid, apdu.cla, apdu.instruction, apdu.p1, apdu.p2,
+ apdu.p3, (char*)apdu.data);
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &apdu, sizeof(RIL_SIM_APDU), pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memsetString(apdu.data);
+#endif
+ free(apdu.data);
+
+#ifdef MEMSET_FREED
+ memset(&apdu, 0, sizeof(RIL_SIM_APDU));
+#endif
+
+ return;
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+
+/**
* Callee expects const RIL_CallForwardInfo *
* Payload is:
* int32_t status/action
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memsetString(cff.number);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI, pRI->socket_id);
return;
invalid:
return;
}
-static void
-dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
- RIL_CDMA_SMS_Message rcsm;
+static status_t
+constructCdmaSms(Parcel &p, RequestInfo *pRI, RIL_CDMA_SMS_Message& rcsm) {
int32_t t;
uint8_t ut;
status_t status;
}
if (status != NO_ERROR) {
- goto invalid;
+ return status;
}
startRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI);
+ return status;
+}
+
+static void
+dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
+ RIL_CDMA_SMS_Message rcsm;
+
+ ALOGD("dispatchCdmaSms");
+ if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) {
+ goto invalid;
+ }
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memset(&rcsm, 0, sizeof(rcsm));
+#endif
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void
+dispatchImsCdmaSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef) {
+ RIL_IMS_SMS_Message rism;
+ RIL_CDMA_SMS_Message rcsm;
+
+ ALOGD("dispatchImsCdmaSms: retry=%d, messageRef=%d", retry, messageRef);
+
+ if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) {
+ goto invalid;
+ }
+ memset(&rism, 0, sizeof(rism));
+ rism.tech = RADIO_TECH_3GPP2;
+ rism.retry = retry;
+ rism.messageRef = messageRef;
+ rism.message.cdmaMessage = &rcsm;
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rism,
+ sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t)
+ +sizeof(rcsm),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsm, 0, sizeof(rcsm));
+ memset(&rism, 0, sizeof(rism));
#endif
return;
}
static void
+dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef) {
+ RIL_IMS_SMS_Message rism;
+ int32_t countStrings;
+ status_t status;
+ size_t datalen;
+ char **pStrings;
+ ALOGD("dispatchImsGsmSms: retry=%d, messageRef=%d", retry, messageRef);
+
+ status = p.readInt32 (&countStrings);
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ memset(&rism, 0, sizeof(rism));
+ rism.tech = RADIO_TECH_3GPP;
+ rism.retry = retry;
+ rism.messageRef = messageRef;
+
+ startRequest;
+ appendPrintBuf("%stech=%d, retry=%d, messageRef=%d, ", printBuf,
+ (int)rism.tech, (int)rism.retry, rism.messageRef);
+ if (countStrings == 0) {
+ // just some non-null pointer
+ pStrings = (char **)alloca(sizeof(char *));
+ datalen = 0;
+ } else if (((int)countStrings) == -1) {
+ pStrings = NULL;
+ datalen = 0;
+ } else {
+ datalen = sizeof(char *) * countStrings;
+
+ pStrings = (char **)alloca(datalen);
+
+ for (int i = 0 ; i < countStrings ; i++) {
+ pStrings[i] = strdupReadString(p);
+ appendPrintBuf("%s%s,", printBuf, pStrings[i]);
+ }
+ }
+ removeLastChar;
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ rism.message.gsmMessage = pStrings;
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rism,
+ sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t)
+ +datalen, pRI, pRI->socket_id);
+
+ if (pStrings != NULL) {
+ for (int i = 0 ; i < countStrings ; i++) {
+#ifdef MEMSET_FREED
+ memsetString (pStrings[i]);
+#endif
+ free(pStrings[i]);
+ }
+
+#ifdef MEMSET_FREED
+ memset(pStrings, 0, datalen);
+#endif
+ }
+
+#ifdef MEMSET_FREED
+ memset(&rism, 0, sizeof(rism));
+#endif
+ return;
+invalid:
+ ALOGE("dispatchImsGsmSms invalid block");
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void
+dispatchImsSms(Parcel &p, RequestInfo *pRI) {
+ int32_t t;
+ status_t status = p.readInt32(&t);
+ RIL_RadioTechnologyFamily format;
+ uint8_t retry;
+ int32_t messageRef;
+
+ ALOGD("dispatchImsSms");
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ format = (RIL_RadioTechnologyFamily) t;
+
+ // read retry field
+ status = p.read(&retry,sizeof(retry));
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ // read messageRef field
+ status = p.read(&messageRef,sizeof(messageRef));
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ if (RADIO_TECH_3GPP == format) {
+ dispatchImsGsmSms(p, pRI, retry, messageRef);
+ } else if (RADIO_TECH_3GPP2 == format) {
+ dispatchImsCdmaSms(p, pRI, retry, messageRef);
+ } else {
+ ALOGE("requestImsSendSMS invalid format value =%d", format);
+ }
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void
dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) {
RIL_CDMA_SMS_Ack rcsa;
int32_t t;
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsa, 0, sizeof(rcsa));
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber,
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
gsmBciPtrs,
num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *),
- pRI);
+ pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo));
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber,
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
cdmaBciPtrs,
num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *),
- pRI);
+ pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo));
printRequest(pRI->token, pRI->pCI->requestNumber);
- s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI, pRI->socket_id);
#ifdef MEMSET_FREED
memset(&rcsw, 0, sizeof(rcsw));
// When all RILs handle this request, this function can be removed and
// the request can be sent directly to the RIL using dispatchVoid.
static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) {
- RIL_RadioState state = s_callbacks.onStateRequest();
+ RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id);
if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
// When all RILs handle this request, this function can be removed and
// the request can be sent directly to the RIL using dispatchVoid.
static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) {
- RIL_RadioState state = s_callbacks.onStateRequest();
+ RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id);
if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
return;
}
- // For Older RILs, that do not support RADIO_STATE_ON, assume that they
- // will not support this new request either and decode CDMA Subscription Source
- // from Radio State
- cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state);
+ // For Older RILs, that do not support RADIO_STATE_ON, assume that they
+ // will not support this new request either and decode CDMA Subscription Source
+ // from Radio State
+ cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state);
+
+ if (cdmaSubscriptionSource < 0)
+ RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
+ else
+ RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int));
+}
+
+static void dispatchSetInitialAttachApn(Parcel &p, RequestInfo *pRI)
+{
+ RIL_InitialAttachApn pf;
+ int32_t t;
+ status_t status;
+
+ memset(&pf, 0, sizeof(pf));
+
+ pf.apn = strdupReadString(p);
+ pf.protocol = strdupReadString(p);
+
+ status = p.readInt32(&t);
+ pf.authtype = (int) t;
+
+ pf.username = strdupReadString(p);
+ pf.password = strdupReadString(p);
+
+ startRequest;
+ appendPrintBuf("%sapn=%s, protocol=%s, authtype=%d, username=%s, password=%s",
+ printBuf, pf.apn, pf.protocol, pf.authtype, pf.username, pf.password);
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memsetString(pf.apn);
+ memsetString(pf.protocol);
+ memsetString(pf.username);
+ memsetString(pf.password);
+#endif
+
+ free(pf.apn);
+ free(pf.protocol);
+ free(pf.username);
+ free(pf.password);
+
+#ifdef MEMSET_FREED
+ memset(&pf, 0, sizeof(pf));
+#endif
+
+ return;
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI) {
+ RIL_NV_ReadItem nvri;
+ int32_t t;
+ status_t status;
+
+ memset(&nvri, 0, sizeof(nvri));
+
+ status = p.readInt32(&t);
+ nvri.itemID = (RIL_NV_Item) t;
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ startRequest;
+ appendPrintBuf("%snvri.itemID=%d, ", printBuf, nvri.itemID);
+ closeRequest;
+
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memset(&nvri, 0, sizeof(nvri));
+#endif
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI) {
+ RIL_NV_WriteItem nvwi;
+ int32_t t;
+ status_t status;
+
+ memset(&nvwi, 0, sizeof(nvwi));
+
+ status = p.readInt32(&t);
+ nvwi.itemID = (RIL_NV_Item) t;
+
+ nvwi.value = strdupReadString(p);
+
+ if (status != NO_ERROR || nvwi.value == NULL) {
+ goto invalid;
+ }
+
+ startRequest;
+ appendPrintBuf("%snvwi.itemID=%d, value=%s, ", printBuf, nvwi.itemID,
+ nvwi.value);
+ closeRequest;
+
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memsetString(nvwi.value);
+#endif
+
+ free(nvwi.value);
+
+#ifdef MEMSET_FREED
+ memset(&nvwi, 0, sizeof(nvwi));
+#endif
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
+
+static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI) {
+ RIL_SelectUiccSub uicc_sub;
+ status_t status;
+ int32_t t;
+ memset(&uicc_sub, 0, sizeof(uicc_sub));
+
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ uicc_sub.slot = (int) t;
+
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ uicc_sub.app_index = (int) t;
+
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ uicc_sub.sub_type = (RIL_SubscriptionType) t;
+
+ status = p.readInt32(&t);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ uicc_sub.act_status = (RIL_UiccSubActStatus) t;
+
+ startRequest;
+ appendPrintBuf("slot=%d, app_index=%d, act_status = %d", uicc_sub.slot, uicc_sub.app_index,
+ uicc_sub.act_status);
+ RLOGD("dispatchUiccSubscription, slot=%d, app_index=%d, act_status = %d", uicc_sub.slot,
+ uicc_sub.app_index, uicc_sub.act_status);
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &uicc_sub, sizeof(uicc_sub), pRI, pRI->socket_id);
- if (cdmaSubscriptionSource < 0)
- RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
- else
- RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int));
+#ifdef MEMSET_FREED
+ memset(&uicc_sub, 0, sizeof(uicc_sub));
+#endif
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
}
-static void dispatchSetInitialAttachApn(Parcel &p, RequestInfo *pRI)
+static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI)
{
- RIL_InitialAttachApn pf;
+ RIL_SimAuthentication pf;
int32_t t;
status_t status;
memset(&pf, 0, sizeof(pf));
- pf.apn = strdupReadString(p);
- pf.protocol = strdupReadString(p);
-
status = p.readInt32(&t);
- pf.authtype = (int) t;
-
- pf.username = strdupReadString(p);
- pf.password = strdupReadString(p);
+ pf.authContext = (int) t;
+ pf.authData = strdupReadString(p);
+ pf.aid = strdupReadString(p);
startRequest;
- appendPrintBuf("%sapn=%s, protocol=%s, auth_type=%d, username=%s, password=%s",
- printBuf, pf.apn, pf.protocol, pf.auth_type, pf.username, pf.password);
+ appendPrintBuf("authContext=%s, authData=%s, aid=%s", pf.authContext, pf.authData, pf.aid);
closeRequest;
printRequest(pRI->token, pRI->pCI->requestNumber);
if (status != NO_ERROR) {
goto invalid;
}
- s_callbacks.onRequest(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI);
+ CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id);
#ifdef MEMSET_FREED
- memsetString(pf.apn);
- memsetString(pf.protocol);
- memsetString(pf.username);
- memsetString(pf.password);
+ memsetString(pf.authData);
+ memsetString(pf.aid);
#endif
- free(pf.apn);
- free(pf.protocol);
- free(pf.username);
- free(pf.password);
+ free(pf.authData);
+ free(pf.aid);
#ifdef MEMSET_FREED
memset(&pf, 0, sizeof(pf));
return;
}
+static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) {
+ int32_t t;
+ status_t status;
+ int32_t num;
+
+ status = p.readInt32(&num);
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+
+ {
+ RIL_DataProfileInfo dataProfiles[num];
+ RIL_DataProfileInfo *dataProfilePtrs[num];
+
+ startRequest;
+ for (int i = 0 ; i < num ; i++ ) {
+ dataProfilePtrs[i] = &dataProfiles[i];
+
+ status = p.readInt32(&t);
+ dataProfiles[i].profileId = (int) t;
+
+ dataProfiles[i].apn = strdupReadString(p);
+ dataProfiles[i].protocol = strdupReadString(p);
+ status = p.readInt32(&t);
+ dataProfiles[i].authType = (int) t;
+
+ dataProfiles[i].user = strdupReadString(p);
+ dataProfiles[i].password = strdupReadString(p);
+
+ status = p.readInt32(&t);
+ dataProfiles[i].type = (int) t;
+
+ status = p.readInt32(&t);
+ dataProfiles[i].maxConnsTime = (int) t;
+ status = p.readInt32(&t);
+ dataProfiles[i].maxConns = (int) t;
+ status = p.readInt32(&t);
+ dataProfiles[i].waitTime = (int) t;
+
+ status = p.readInt32(&t);
+ dataProfiles[i].enabled = (int) t;
+
+ appendPrintBuf("%s [%d: profileId=%d, apn =%s, protocol =%s, authType =%d, \
+ user =%s, password =%s, type =%d, maxConnsTime =%d, maxConns =%d, \
+ waitTime =%d, enabled =%d]", printBuf, i, dataProfiles[i].profileId,
+ dataProfiles[i].apn, dataProfiles[i].protocol, dataProfiles[i].authType,
+ dataProfiles[i].user, dataProfiles[i].password, dataProfiles[i].type,
+ dataProfiles[i].maxConnsTime, dataProfiles[i].maxConns,
+ dataProfiles[i].waitTime, dataProfiles[i].enabled);
+ }
+ closeRequest;
+ printRequest(pRI->token, pRI->pCI->requestNumber);
+
+ if (status != NO_ERROR) {
+ goto invalid;
+ }
+ CALL_ONREQUEST(pRI->pCI->requestNumber,
+ dataProfilePtrs,
+ num * sizeof(RIL_DataProfileInfo *),
+ pRI, pRI->socket_id);
+
+#ifdef MEMSET_FREED
+ memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo));
+ memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *));
+#endif
+ }
+
+ return;
+
+invalid:
+ invalidCommandBlock(pRI);
+ return;
+}
+
static int
blockingWrite(int fd, const void *buffer, size_t len) {
size_t writeOffset = 0;
}
static int
-sendResponseRaw (const void *data, size_t dataSize) {
- int fd = s_fdCommand;
+sendResponseRaw (const void *data, size_t dataSize, RIL_SOCKET_ID socket_id) {
+ int fd = s_ril_param_socket.fdCommand;
int ret;
uint32_t header;
+ pthread_mutex_t * writeMutexHook = &s_writeMutex;
- if (s_fdCommand < 0) {
+ RLOGE("Send Response to %s", rilSocketIdToString(socket_id));
+
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ fd = s_ril_param_socket2.fdCommand;
+ writeMutexHook = &s_writeMutex_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ else if (socket_id == RIL_SOCKET_3) {
+ fd = s_ril_param_socket3.fdCommand;
+ writeMutexHook = &s_writeMutex_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ else if (socket_id == RIL_SOCKET_4) {
+ fd = s_ril_param_socket4.fdCommand;
+ writeMutexHook = &s_writeMutex_socket4;
+ }
+#endif
+#endif
+ if (fd < 0) {
return -1;
}
return -1;
}
- pthread_mutex_lock(&s_writeMutex);
+ pthread_mutex_lock(writeMutexHook);
header = htonl(dataSize);
ret = blockingWrite(fd, (void *)&header, sizeof(header));
if (ret < 0) {
- pthread_mutex_unlock(&s_writeMutex);
+ pthread_mutex_unlock(writeMutexHook);
return ret;
}
ret = blockingWrite(fd, data, dataSize);
if (ret < 0) {
- pthread_mutex_unlock(&s_writeMutex);
+ pthread_mutex_unlock(writeMutexHook);
return ret;
}
- pthread_mutex_unlock(&s_writeMutex);
+ pthread_mutex_unlock(writeMutexHook);
return 0;
}
static int
-sendResponse (Parcel &p) {
+sendResponse (Parcel &p, RIL_SOCKET_ID socket_id) {
printResponse;
- return sendResponseRaw(p.data(), p.dataSize());
+ return sendResponseRaw(p.data(), p.dataSize(), socket_id);
}
-/** response is an int* pointing to an array of ints*/
+/** response is an int* pointing to an array of ints */
static int
responseInts(Parcel &p, void *response, size_t responselen) {
return RIL_ERRNO_INVALID_RESPONSE;
}
if (responselen % sizeof(int) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseInts: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof(int));
return RIL_ERRNO_INVALID_RESPONSE;
}
int *p_int = (int *) response;
- numInts = responselen / sizeof(int *);
+ numInts = responselen / sizeof(int);
p.writeInt32 (numInts);
/* each int*/
return RIL_ERRNO_INVALID_RESPONSE;
}
if (responselen % sizeof(char *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseStrings: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof(char *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen % sizeof (RIL_Call *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseCallList: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof (RIL_Call *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
+ RLOGE("responseDataCallListV4: invalid response length %d expected multiple of %d",
(int)responselen, (int)sizeof(RIL_Data_Call_Response_v4));
return RIL_ERRNO_INVALID_RESPONSE;
}
+ // Write version
+ p.writeInt32(4);
+
int num = responselen / sizeof(RIL_Data_Call_Response_v4);
p.writeInt32(num);
return 0;
}
-static int responseDataCallList(Parcel &p, void *response, size_t responselen)
+static int responseDataCallListV6(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_Data_Call_Response_v6) != 0) {
+ RLOGE("responseDataCallListV6: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
// Write version
- p.writeInt32(s_callbacks.version);
+ p.writeInt32(6);
+ int num = responselen / sizeof(RIL_Data_Call_Response_v6);
+ p.writeInt32(num);
+
+ RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) 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);
+ appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", 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);
+ }
+ removeLastChar;
+ closeResponse;
+
+ return 0;
+}
+
+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 (response == NULL && responselen != 0) {
return RIL_ERRNO_INVALID_RESPONSE;
}
- if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
- (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
+ // Support v6 or v9 with new rils
+ if (responselen % sizeof(RIL_Data_Call_Response_v6) == 0) {
+ RLOGD("responseDataCallList: v6");
+ return responseDataCallListV6(p, response, responselen);
+ }
+
+ if (responselen % sizeof(RIL_Data_Call_Response_v9) != 0) {
+ RLOGE("responseDataCallList: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_Data_Call_Response_v9));
return RIL_ERRNO_INVALID_RESPONSE;
}
- int num = responselen / sizeof(RIL_Data_Call_Response_v6);
+ // Write version
+ p.writeInt32(10);
+
+ int num = responselen / sizeof(RIL_Data_Call_Response_v9);
p.writeInt32(num);
- RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
+ RIL_Data_Call_Response_v9 *p_cur = (RIL_Data_Call_Response_v9 *) response;
startResponse;
int i;
for (i = 0; i < num; i++) {
writeStringToParcel(p, p_cur[i].addresses);
writeStringToParcel(p, p_cur[i].dnses);
writeStringToParcel(p, p_cur[i].gateways);
- appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf,
+ writeStringToParcel(p, p_cur[i].pcscf);
+ appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s],", printBuf,
p_cur[i].status,
p_cur[i].suggestedRetryTime,
p_cur[i].cid,
(char*)p_cur[i].ifname,
(char*)p_cur[i].addresses,
(char*)p_cur[i].dnses,
- (char*)p_cur[i].gateways);
+ (char*)p_cur[i].gateways,
+ (char*)p_cur[i].pcscf);
}
removeLastChar;
closeResponse;
}
if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
+ RLOGE("responseCallForwards: invalid response length %d expected multiple of %d",
(int)responselen, (int)sizeof(RIL_CallForwardInfo *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseCellList: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof (RIL_NeighboringCell *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
- RLOGE("invalid response length %d expected multiple of %d\n",
+ RLOGE("responseCdmaInformationRecords: invalid response length %d expected multiple of %d\n",
(int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
return RIL_ERRNO_INVALID_RESPONSE;
}
}
if (responselen >= sizeof (RIL_SignalStrength_v5)) {
- RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response);
+ 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->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(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);
}
startResponse;
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]",
+ 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->LTE_SignalStrength.rsrp,
p_cur->LTE_SignalStrength.rsrq,
p_cur->LTE_SignalStrength.rssnr,
- p_cur->LTE_SignalStrength.cqi);
+ p_cur->LTE_SignalStrength.cqi,
+ p_cur->TD_SCDMA_SignalStrength.rscp);
closeResponse;
} else {
}
if (responselen % sizeof(RIL_CellInfo) != 0) {
- RLOGE("invalid response length %d expected multiple of %d",
+ RLOGE("responseCellInfoList: invalid response length %d expected multiple of %d",
(int)responselen, (int)sizeof(RIL_CellInfo));
return RIL_ERRNO_INVALID_RESPONSE;
}
p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
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;
}
return 0;
}
+static int responseHardwareConfig(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_HardwareConfig) != 0) {
+ RLOGE("responseHardwareConfig: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_HardwareConfig));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ int num = responselen / sizeof(RIL_HardwareConfig);
+ int i;
+ RIL_HardwareConfig *p_cur = (RIL_HardwareConfig *) response;
+
+ p.writeInt32(num);
+
+ startResponse;
+ for (i = 0; i < num; i++) {
+ switch (p_cur[i].type) {
+ case RIL_HARDWARE_CONFIG_MODEM: {
+ writeStringToParcel(p, p_cur[i].uuid);
+ p.writeInt32((int)p_cur[i].state);
+ p.writeInt32(p_cur[i].cfg.modem.rat);
+ p.writeInt32(p_cur[i].cfg.modem.maxVoice);
+ p.writeInt32(p_cur[i].cfg.modem.maxData);
+ p.writeInt32(p_cur[i].cfg.modem.maxStandby);
+
+ appendPrintBuf("%s modem: uuid=%s,state=%d,rat=%08x,maxV=%d,maxD=%d,maxS=%d", printBuf,
+ p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.modem.rat,
+ p_cur[i].cfg.modem.maxVoice, p_cur[i].cfg.modem.maxData, p_cur[i].cfg.modem.maxStandby);
+ break;
+ }
+ case RIL_HARDWARE_CONFIG_SIM: {
+ writeStringToParcel(p, p_cur[i].uuid);
+ p.writeInt32((int)p_cur[i].state);
+ writeStringToParcel(p, p_cur[i].cfg.sim.modemUuid);
+
+ appendPrintBuf("%s sim: uuid=%s,state=%d,modem-uuid=%s", printBuf,
+ p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.sim.modemUuid);
+ break;
+ }
+ }
+ }
+ removeLastChar;
+ closeResponse;
+ return 0;
+}
+
static void triggerEvLoop() {
int ret;
if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
return 0;
}
+static int responseDcRtInfo(Parcel &p, void *response, size_t responselen)
+{
+ int num = responselen / sizeof(RIL_DcRtInfo);
+ if ((responselen % sizeof(RIL_DcRtInfo) != 0) || (num != 1)) {
+ RLOGE("responseDcRtInfo: invalid response length %d expected multiple of %d",
+ (int)responselen, (int)sizeof(RIL_DcRtInfo));
+ return RIL_ERRNO_INVALID_RESPONSE;
+ }
+
+ startResponse;
+ RIL_DcRtInfo *pDcRtInfo = (RIL_DcRtInfo *)response;
+ p.writeInt64(pDcRtInfo->time);
+ p.writeInt32(pDcRtInfo->powerState);
+ appendPrintBuf("%s[time=%d,powerState=%d]", printBuf,
+ pDcRtInfo->time,
+ pDcRtInfo->powerState);
+ 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
} while (ret > 0 || (ret < 0 && errno == EINTR));
}
-static void onCommandsSocketClosed() {
+static void onCommandsSocketClosed(RIL_SOCKET_ID socket_id) {
int ret;
RequestInfo *p_cur;
-
+ /* Hook for current context
+ pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t * pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo ** pendingRequestsHook = &s_pendingRequests;
+
+#if (SIM_COUNT >= 2)
+ if (socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ else if (socket_id == RIL_SOCKET_3) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
+ pendingRequestsHook = &s_pendingRequests_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ else if (socket_id == RIL_SOCKET_4) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
+ pendingRequestsHook = &s_pendingRequests_socket4;
+ }
+#endif
+#endif
/* mark pending requests as "cancelled" so we dont report responses */
-
- ret = pthread_mutex_lock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_lock(pendingRequestsMutexHook);
assert (ret == 0);
- p_cur = s_pendingRequests;
+ p_cur = *pendingRequestsHook;
- for (p_cur = s_pendingRequests
+ for (p_cur = *pendingRequestsHook
; p_cur != NULL
; p_cur = p_cur->p_next
) {
p_cur->cancelled = 1;
}
- ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
+ ret = pthread_mutex_unlock(pendingRequestsMutexHook);
assert (ret == 0);
}
void *p_record;
size_t recordlen;
int ret;
+ SocketListenParam *p_info = (SocketListenParam *)param;
- assert(fd == s_fdCommand);
+ assert(fd == p_info->fdCommand);
- p_rs = (RecordStream *)param;
+ p_rs = p_info->p_rs;
for (;;) {
/* loop until EAGAIN/EINTR, end of stream, or other error */
} else if (ret < 0) {
break;
} else if (ret == 0) { /* && p_record != NULL */
- processCommandBuffer(p_record, recordlen);
+ processCommandBuffer(p_record, recordlen, p_info->socket_id);
}
}
RLOGW("EOS. Closing command socket.");
}
- close(s_fdCommand);
- s_fdCommand = -1;
+ close(fd);
+ p_info->fdCommand = -1;
- ril_event_del(&s_commands_event);
+ ril_event_del(p_info->commands_event);
record_stream_free(p_rs);
/* start listening for new connections again */
rilEventAddWakeup(&s_listen_event);
- onCommandsSocketClosed();
+ onCommandsSocketClosed(p_info->socket_id);
}
}
-static void onNewCommandConnect() {
+static void onNewCommandConnect(RIL_SOCKET_ID socket_id) {
// Inform we are connected and the ril version
int rilVer = s_callbacks.version;
- RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED,
- &rilVer, sizeof(rilVer));
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RIL_CONNECTED,
+ &rilVer, sizeof(rilVer), socket_id);
// implicit radio state changed
- RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
- NULL, 0);
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
+ NULL, 0, socket_id);
// Send last NITZ time data, in case it was missed
if (s_lastNITZTimeData != NULL) {
- sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
+ sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize, socket_id);
free(s_lastNITZTimeData);
s_lastNITZTimeData = NULL;
int ret;
int err;
int is_phone_socket;
+ int fdCommand = -1;
RecordStream *p_rs;
+ SocketListenParam *p_info = (SocketListenParam *)param;
struct sockaddr_un peeraddr;
socklen_t socklen = sizeof (peeraddr);
struct passwd *pwd = NULL;
- assert (s_fdCommand < 0);
- assert (fd == s_fdListen);
+ assert (*p_info->fdCommand < 0);
+ assert (fd == *p_info->fdListen);
- s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
+ fdCommand = accept(fd, (sockaddr *) &peeraddr, &socklen);
- if (s_fdCommand < 0 ) {
+ if (fdCommand < 0 ) {
RLOGE("Error on accept() errno:%d", errno);
/* start listening for new connections again */
- rilEventAddWakeup(&s_listen_event);
- return;
+ rilEventAddWakeup(p_info->listen_event);
+ return;
}
/* check the credential of the other side and only accept socket from
errno = 0;
is_phone_socket = 0;
- err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
+ err = getsockopt(fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
if (err == 0 && szCreds > 0) {
errno = 0;
pwd = getpwuid(creds.uid);
if (pwd != NULL) {
- if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
+ if (strcmp(pwd->pw_name, p_info->processName) == 0) {
is_phone_socket = 1;
} else {
RLOGE("RILD can't accept socket from process %s", pwd->pw_name);
RLOGD("Error on getsockopt() errno: %d", errno);
}
- if ( !is_phone_socket ) {
- RLOGE("RILD must accept socket from %s", PHONE_PROCESS);
+ if (!is_phone_socket) {
+ RLOGE("RILD must accept socket from %s", p_info->processName);
- close(s_fdCommand);
- s_fdCommand = -1;
+ close(fdCommand);
+ fdCommand = -1;
- onCommandsSocketClosed();
+ onCommandsSocketClosed(p_info->socket_id);
/* start listening for new connections again */
- rilEventAddWakeup(&s_listen_event);
+ rilEventAddWakeup(p_info->listen_event);
return;
}
- ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
+ ret = fcntl(fdCommand, F_SETFL, O_NONBLOCK);
if (ret < 0) {
RLOGE ("Error setting O_NONBLOCK errno:%d", errno);
}
- RLOGI("libril: new connection");
+ RLOGI("libril: new connection to %s", rilSocketIdToString(p_info->socket_id));
+
+ p_info->fdCommand = fdCommand;
- p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
+ p_rs = record_stream_new(p_info->fdCommand, MAX_COMMAND_BYTES);
- ril_event_set (&s_commands_event, s_fdCommand, 1,
- processCommandsCallback, p_rs);
+ p_info->p_rs = p_rs;
- rilEventAddWakeup (&s_commands_event);
+ ril_event_set (p_info->commands_event, p_info->fdCommand, 1,
+ p_info->processCommandsCallback, p_info);
- onNewCommandConnect();
+ rilEventAddWakeup (p_info->commands_event);
+
+ onNewCommandConnect(p_info->socket_id);
}
static void freeDebugCallbackArgs(int number, char **args) {
int hangupData[1] = {1};
int number;
char **args;
+ RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
+ int sim_id = 0;
+
+ RLOGI("debugCallback for socket %s", rilSocketIdToString(socket_id));
acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen);
}
char * buf = args[i];
buf[len] = 0;
+ if ((i+1) == number) {
+ /* The last argument should be sim id 0(SIM1)~3(SIM4) */
+ sim_id = atoi(args[i]);
+ switch (sim_id) {
+ case 0:
+ socket_id = RIL_SOCKET_1;
+ break;
+ #if (SIM_COUNT >= 2)
+ case 1:
+ socket_id = RIL_SOCKET_2;
+ break;
+ #endif
+ #if (SIM_COUNT >= 3)
+ case 2:
+ socket_id = RIL_SOCKET_3;
+ break;
+ #endif
+ #if (SIM_COUNT >= 4)
+ case 3:
+ socket_id = RIL_SOCKET_4;
+ break;
+ #endif
+ default:
+ socket_id = RIL_SOCKET_1;
+ break;
+ }
+ }
}
switch (atoi(args[0])) {
case 0:
RLOGI ("Connection on debug port: issuing reset.");
- issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
+ issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0, socket_id);
break;
case 1:
RLOGI ("Connection on debug port: issuing radio power off.");
data = 0;
- issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
+ issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id);
// Close the socket
- close(s_fdCommand);
- s_fdCommand = -1;
+ if (socket_id == RIL_SOCKET_1 && s_ril_param_socket.fdCommand > 0) {
+ close(s_ril_param_socket.fdCommand);
+ s_ril_param_socket.fdCommand = -1;
+ }
+ #if (SIM_COUNT == 2)
+ else if (socket_id == RIL_SOCKET_2 && s_ril_param_socket2.fdCommand > 0) {
+ close(s_ril_param_socket2.fdCommand);
+ s_ril_param_socket2.fdCommand = -1;
+ }
+ #endif
break;
case 2:
RLOGI ("Debug port: issuing unsolicited voice network change.");
- RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
- NULL, 0);
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0, socket_id);
break;
case 3:
RLOGI ("Debug port: QXDM log enable.");
qxdm_data[4] = 0; // log_mask
qxdm_data[5] = 8; // log_max_fileindex
issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
- 6 * sizeof(int));
+ 6 * sizeof(int), socket_id);
break;
case 4:
RLOGI ("Debug port: QXDM log disable.");
qxdm_data[4] = 0;
qxdm_data[5] = 8;
issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
- 6 * sizeof(int));
+ 6 * sizeof(int), socket_id);
break;
case 5:
RLOGI("Debug port: Radio On");
data = 1;
- issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
+ issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id);
sleep(2);
// Set network selection automatic.
- issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
+ 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));
+ sizeof(actData), socket_id);
break;
case 7:
RLOGI("Debug port: Deactivate Data Call");
issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
- sizeof(deactData));
+ sizeof(deactData), socket_id);
break;
case 8:
RLOGI("Debug port: Dial Call");
dialData.clir = 0;
dialData.address = args[1];
- issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
+ issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData), socket_id);
break;
case 9:
RLOGI("Debug port: Answer Call");
- issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
+ issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0, socket_id);
break;
case 10:
RLOGI("Debug port: End Call");
issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
- sizeof(hangupData));
+ sizeof(hangupData), socket_id);
break;
default:
RLOGE ("Invalid request");
extern "C" void
RIL_startEventLoop(void) {
- int ret;
- pthread_attr_t attr;
-
/* spin up eventLoop thread and wait for it to get started */
s_started = 0;
pthread_mutex_lock(&s_startupMutex);
- pthread_attr_init (&attr);
+ pthread_attr_t attr;
+ pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
+
+ int result = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
+ if (result != 0) {
+ RLOGE("Failed to create dispatch thread: %s", strerror(result));
+ goto done;
+ }
while (s_started == 0) {
pthread_cond_wait(&s_startupCond, &s_startupMutex);
}
+done:
pthread_mutex_unlock(&s_startupMutex);
-
- if (ret < 0) {
- RLOGE("Failed to create dispatch thread errno:%d", errno);
- return;
- }
}
// Used for testing purpose only.
memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
}
+static void startListen(RIL_SOCKET_ID socket_id, SocketListenParam* socket_listen_p) {
+ int fdListen = -1;
+ int ret;
+ char socket_name[10];
+
+ memset(socket_name, 0, sizeof(char)*10);
+
+ switch(socket_id) {
+ case RIL_SOCKET_1:
+ strncpy(socket_name, RIL_getRilSocketName(), 9);
+ break;
+ #if (SIM_COUNT >= 2)
+ case RIL_SOCKET_2:
+ strncpy(socket_name, SOCKET2_NAME_RIL, 9);
+ break;
+ #endif
+ #if (SIM_COUNT >= 3)
+ case RIL_SOCKET_3:
+ strncpy(socket_name, SOCKET3_NAME_RIL, 9);
+ break;
+ #endif
+ #if (SIM_COUNT >= 4)
+ case RIL_SOCKET_4:
+ strncpy(socket_name, SOCKET4_NAME_RIL, 9);
+ break;
+ #endif
+ default:
+ RLOGE("Socket id is wrong!!");
+ return;
+ }
+
+ RLOGI("Start to listen %s", rilSocketIdToString(socket_id));
+
+ fdListen = android_get_control_socket(socket_name);
+ if (fdListen < 0) {
+ RLOGE("Failed to get socket %s", socket_name);
+ exit(-1);
+ }
+
+ ret = listen(fdListen, 4);
+
+ if (ret < 0) {
+ RLOGE("Failed to listen on control socket '%d': %s",
+ fdListen, strerror(errno));
+ exit(-1);
+ }
+ socket_listen_p->fdListen = fdListen;
+
+ /* note: non-persistent so we can accept only one connection at a time */
+ ril_event_set (socket_listen_p->listen_event, fdListen, false,
+ listenCallback, socket_listen_p);
+
+ rilEventAddWakeup (socket_listen_p->listen_event);
+}
+
extern "C" void
RIL_register (const RIL_RadioFunctions *callbacks) {
int ret;
int flags;
+ RLOGI("SIM_COUNT: %d", SIM_COUNT);
+
if (callbacks == NULL) {
RLOGE("RIL_register: RIL_RadioFunctions * null");
return;
memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
+ /* Initialize socket1 parameters */
+ s_ril_param_socket = {
+ RIL_SOCKET_1, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event, /* commands_event */
+ &s_listen_event, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+
+#if (SIM_COUNT >= 2)
+ s_ril_param_socket2 = {
+ RIL_SOCKET_2, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event_socket2, /* commands_event */
+ &s_listen_event_socket2, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+#endif
+
+#if (SIM_COUNT >= 3)
+ s_ril_param_socket3 = {
+ RIL_SOCKET_3, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event_socket3, /* commands_event */
+ &s_listen_event_socket3, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+#endif
+
+#if (SIM_COUNT >= 4)
+ s_ril_param_socket4 = {
+ RIL_SOCKET_4, /* socket_id */
+ -1, /* fdListen */
+ -1, /* fdCommand */
+ PHONE_PROCESS, /* processName */
+ &s_commands_event_socket4, /* commands_event */
+ &s_listen_event_socket4, /* listen_event */
+ processCommandsCallback, /* processCommandsCallback */
+ NULL /* p_rs */
+ };
+#endif
+
+
s_registerCalled = 1;
+ RLOGI("s_registerCalled flag set, %d", s_started);
// Little self-check
for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
RIL_startEventLoop();
}
- // start listen socket
-
-#if 0
- ret = socket_local_server (SOCKET_NAME_RIL,
- ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
-
- if (ret < 0) {
- RLOGE("Unable to bind socket errno:%d", errno);
- exit (-1);
- }
- s_fdListen = ret;
-
-#else
- s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
- if (s_fdListen < 0) {
- RLOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
- exit(-1);
- }
-
- ret = listen(s_fdListen, 4);
+ // start listen socket1
+ startListen(RIL_SOCKET_1, &s_ril_param_socket);
- if (ret < 0) {
- RLOGE("Failed to listen on control socket '%d': %s",
- s_fdListen, strerror(errno));
- exit(-1);
- }
-#endif
+#if (SIM_COUNT >= 2)
+ // start listen socket2
+ startListen(RIL_SOCKET_2, &s_ril_param_socket2);
+#endif /* (SIM_COUNT == 2) */
+#if (SIM_COUNT >= 3)
+ // start listen socket3
+ startListen(RIL_SOCKET_3, &s_ril_param_socket3);
+#endif /* (SIM_COUNT == 3) */
- /* note: non-persistent so we can accept only one connection at a time */
- ril_event_set (&s_listen_event, s_fdListen, false,
- listenCallback, NULL);
+#if (SIM_COUNT >= 4)
+ // start listen socket4
+ startListen(RIL_SOCKET_4, &s_ril_param_socket4);
+#endif /* (SIM_COUNT == 4) */
- rilEventAddWakeup (&s_listen_event);
#if 1
// start debug interface socket
- s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
+ char *inst = NULL;
+ if (strlen(RIL_getRilSocketName()) >= strlen(SOCKET_NAME_RIL)) {
+ inst = RIL_getRilSocketName() + strlen(SOCKET_NAME_RIL);
+ }
+
+ char rildebug[MAX_DEBUG_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL_DEBUG;
+ if (inst != NULL) {
+ strncat(rildebug, inst, MAX_DEBUG_SOCKET_NAME_LENGTH);
+ }
+
+ s_fdDebug = android_get_control_socket(rildebug);
if (s_fdDebug < 0) {
- RLOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
+ RLOGE("Failed to get socket : %s errno:%d", rildebug, errno);
exit(-1);
}
static int
checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
int ret = 0;
+ /* Hook for current context
+ pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
+ pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
+ /* pendingRequestsHook refer to &s_pendingRequests */
+ RequestInfo ** pendingRequestsHook = &s_pendingRequests;
if (pRI == NULL) {
return 0;
}
- pthread_mutex_lock(&s_pendingRequestsMutex);
+#if (SIM_COUNT >= 2)
+ if (pRI->socket_id == RIL_SOCKET_2) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
+ pendingRequestsHook = &s_pendingRequests_socket2;
+ }
+#if (SIM_COUNT >= 3)
+ if (pRI->socket_id == RIL_SOCKET_3) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
+ pendingRequestsHook = &s_pendingRequests_socket3;
+ }
+#endif
+#if (SIM_COUNT >= 4)
+ if (pRI->socket_id == RIL_SOCKET_4) {
+ pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
+ pendingRequestsHook = &s_pendingRequests_socket4;
+ }
+#endif
+#endif
+ pthread_mutex_lock(pendingRequestsMutexHook);
- for(RequestInfo **ppCur = &s_pendingRequests
+ for(RequestInfo **ppCur = pendingRequestsHook
; *ppCur != NULL
; ppCur = &((*ppCur)->p_next)
) {
}
}
- pthread_mutex_unlock(&s_pendingRequestsMutex);
+ pthread_mutex_unlock(pendingRequestsMutexHook);
return ret;
}
RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
RequestInfo *pRI;
int ret;
+ int fd = s_ril_param_socket.fdCommand;
size_t errorOffset;
+ RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
pRI = (RequestInfo *)t;
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
+ RLOGD("RequestComplete, %s", rilSocketIdToString(socket_id));
+
if (pRI->local > 0) {
// Locally issued command...void only!
// response does not go back up the command socket
/* if an error occurred, rewind and mark it */
if (ret != 0) {
+ RLOGE ("responseFunction error, ret %d", ret);
p.setDataPosition(errorOffset);
p.writeInt32 (ret);
}
appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
}
- if (s_fdCommand < 0) {
+ if (fd < 0) {
RLOGD ("RIL onRequestComplete: Command channel closed");
}
- sendResponse(p);
+ sendResponse(p, socket_id);
}
done:
* returned when telephony framework requests them
*/
static RIL_RadioState
-processRadioState(RIL_RadioState newRadioState) {
+processRadioState(RIL_RadioState newRadioState, RIL_SOCKET_ID socket_id) {
if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) {
int newVoiceRadioTech;
newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState);
if(newVoiceRadioTech != voiceRadioTech) {
voiceRadioTech = newVoiceRadioTech;
- RIL_onUnsolicitedResponse (RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
- &voiceRadioTech, sizeof(voiceRadioTech));
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
+ &voiceRadioTech, sizeof(voiceRadioTech), socket_id);
}
if(is3gpp2(newVoiceRadioTech)) {
newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState);
if(newCdmaSubscriptionSource != cdmaSubscriptionSource) {
cdmaSubscriptionSource = newCdmaSubscriptionSource;
- RIL_onUnsolicitedResponse (RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
- &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource));
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
+ &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource), socket_id);
}
}
newSimStatus = decodeSimStatus(newRadioState);
if(newSimStatus != simRuimStatus) {
simRuimStatus = newSimStatus;
- RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
+ RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0, socket_id);
}
/* Send RADIO_ON to telephony */
return newRadioState;
}
+
+#if defined(ANDROID_MULTI_SIM)
+extern "C"
+void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
+ size_t datalen, RIL_SOCKET_ID socket_id)
+#else
extern "C"
void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
size_t datalen)
+#endif
{
int unsolResponseIndex;
int ret;
int64_t timeReceived = 0;
bool shouldScheduleTimeout = false;
RIL_RadioState newState;
+ RIL_SOCKET_ID soc_id = RIL_SOCKET_1;
+
+#if defined(ANDROID_MULTI_SIM)
+ soc_id = socket_id;
+#endif
+
if (s_registerCalled == 0) {
// Ignore RIL_onUnsolicitedResponse before RIL_register
p.writeInt32 (unsolResponse);
ret = s_unsolResponses[unsolResponseIndex]
- .responseFunction(p, data, datalen);
+ .responseFunction(p, const_cast<void*>(data), datalen);
if (ret != 0) {
// Problem with the response. Don't continue;
goto error_exit;
// some things get more payload
switch(unsolResponse) {
case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
- newState = processRadioState(s_callbacks.onStateRequest());
+ newState = processRadioState(CALL_ONSTATEREQUEST(soc_id), soc_id);
p.writeInt32(newState);
appendPrintBuf("%s {%s}", printBuf,
- radioStateToString(s_callbacks.onStateRequest()));
+ radioStateToString(CALL_ONSTATEREQUEST(soc_id)));
break;
break;
}
- ret = sendResponse(p);
+ RLOGI("%s UNSOLICITED: %s length:%d", rilSocketIdToString(soc_id), requestToString(unsolResponse), p.dataSize());
+ ret = sendResponse(p, soc_id);
if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
// Unfortunately, NITZ time is not poll/update like everything
case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
+ case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE";
+ case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC";
+ case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
+ case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
+ case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+ case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
+ 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_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";
case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
+ case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
+ case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
default: return "<unknown request>";
}
}
+const char *
+rilSocketIdToString(RIL_SOCKET_ID socket_id)
+{
+ switch(socket_id) {
+ case RIL_SOCKET_1:
+ return "RIL_SOCKET_1";
+#if (SIM_COUNT >= 2)
+ case RIL_SOCKET_2:
+ return "RIL_SOCKET_2";
+#endif
+#if (SIM_COUNT >= 3)
+ case RIL_SOCKET_3:
+ return "RIL_SOCKET_3";
+#endif
+#if (SIM_COUNT >= 4)
+ case RIL_SOCKET_4:
+ return "RIL_SOCKET_4";
+#endif
+ default:
+ return "not a valid RIL";
+ }
+}
+
} /* namespace android */
OSDN Git Service
