1 /* //device/libs/telephony/ril.cpp
3 ** Copyright 2006, The Android Open Source Project
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
9 ** http://www.apache.org/licenses/LICENSE-2.0
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
18 #define LOG_TAG "RILC"
20 #include <hardware_legacy/power.h>
22 #include <telephony/ril.h>
23 #include <telephony/ril_cdma_sms.h>
24 #include <cutils/sockets.h>
25 #include <cutils/jstring.h>
26 #include <cutils/record_stream.h>
27 #include <utils/Log.h>
28 #include <utils/SystemClock.h>
30 #include <binder/Parcel.h>
31 #include <cutils/jstring.h>
33 #include <sys/types.h>
49 #include <netinet/in.h>
50 #include <cutils/properties.h>
52 #include <ril_event.h>
56 #define PHONE_PROCESS "radio"
58 #define SOCKET_NAME_RIL "rild"
59 #define SOCKET_NAME_RIL_DEBUG "rild-debug"
61 #define ANDROID_WAKE_LOCK_NAME "radio-interface"
64 #define PROPERTY_RIL_IMPL "gsm.version.ril-impl"
66 // match with constant in RIL.java
67 #define MAX_COMMAND_BYTES (8 * 1024)
69 // Basically: memset buffers that the client library
70 // shouldn't be using anymore in an attempt to find
71 // memory usage issues sooner.
72 #define MEMSET_FREED 1
74 #define NUM_ELEMS(a) (sizeof (a) / sizeof (a)[0])
76 #define MIN(a,b) ((a)<(b) ? (a) : (b))
78 /* Constants for response types */
79 #define RESPONSE_SOLICITED 0
80 #define RESPONSE_UNSOLICITED 1
82 /* Negative values for private RIL errno's */
83 #define RIL_ERRNO_INVALID_RESPONSE -1
85 // request, response, and unsolicited msg print macro
86 #define PRINTBUF_SIZE 8096
92 #define startRequest sprintf(printBuf, "(")
93 #define closeRequest sprintf(printBuf, "%s)", printBuf)
94 #define printRequest(token, req) \
95 LOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
97 #define startResponse sprintf(printBuf, "%s {", printBuf)
98 #define closeResponse sprintf(printBuf, "%s}", printBuf)
99 #define printResponse LOGD("%s", printBuf)
101 #define clearPrintBuf printBuf[0] = 0
102 #define removeLastChar printBuf[strlen(printBuf)-1] = 0
103 #define appendPrintBuf(x...) sprintf(printBuf, x)
107 #define printRequest(token, req)
108 #define startResponse
109 #define closeResponse
110 #define printResponse
111 #define clearPrintBuf
112 #define removeLastChar
113 #define appendPrintBuf(x...)
116 enum WakeType {DONT_WAKE, WAKE_PARTIAL};
120 void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);
121 int(*responseFunction) (Parcel &p, void *response, size_t responselen);
126 int (*responseFunction) (Parcel &p, void *response, size_t responselen);
130 typedef struct RequestInfo {
131 int32_t token; //this is not RIL_Token
133 struct RequestInfo *p_next;
135 char local; // responses to local commands do not go back to command process
138 typedef struct UserCallbackInfo {
139 RIL_TimedCallback p_callback;
141 struct ril_event event;
142 struct UserCallbackInfo *p_next;
146 /*******************************************************************/
148 RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
149 static int s_registerCalled = 0;
151 static pthread_t s_tid_dispatch;
152 static pthread_t s_tid_reader;
153 static int s_started = 0;
155 static int s_fdListen = -1;
156 static int s_fdCommand = -1;
157 static int s_fdDebug = -1;
159 static int s_fdWakeupRead;
160 static int s_fdWakeupWrite;
162 static struct ril_event s_commands_event;
163 static struct ril_event s_wakeupfd_event;
164 static struct ril_event s_listen_event;
165 static struct ril_event s_wake_timeout_event;
166 static struct ril_event s_debug_event;
169 static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0};
171 static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
172 static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
173 static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
174 static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
176 static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
177 static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
179 static RequestInfo *s_pendingRequests = NULL;
181 static RequestInfo *s_toDispatchHead = NULL;
182 static RequestInfo *s_toDispatchTail = NULL;
184 static UserCallbackInfo *s_last_wake_timeout_info = NULL;
186 static void *s_lastNITZTimeData = NULL;
187 static size_t s_lastNITZTimeDataSize;
190 static char printBuf[PRINTBUF_SIZE];
193 /*******************************************************************/
195 static void dispatchVoid (Parcel& p, RequestInfo *pRI);
196 static void dispatchString (Parcel& p, RequestInfo *pRI);
197 static void dispatchStrings (Parcel& p, RequestInfo *pRI);
198 static void dispatchInts (Parcel& p, RequestInfo *pRI);
199 static void dispatchDial (Parcel& p, RequestInfo *pRI);
200 static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI);
201 static void dispatchCallForward(Parcel& p, RequestInfo *pRI);
202 static void dispatchRaw(Parcel& p, RequestInfo *pRI);
203 static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI);
204 static void dispatchDataCall (Parcel& p, RequestInfo *pRI);
206 static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI);
207 static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI);
208 static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI);
209 static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI);
210 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI);
211 static int responseInts(Parcel &p, void *response, size_t responselen);
212 static int responseStrings(Parcel &p, void *response, size_t responselen);
213 static int responseString(Parcel &p, void *response, size_t responselen);
214 static int responseVoid(Parcel &p, void *response, size_t responselen);
215 static int responseCallList(Parcel &p, void *response, size_t responselen);
216 static int responseSMS(Parcel &p, void *response, size_t responselen);
217 static int responseSIM_IO(Parcel &p, void *response, size_t responselen);
218 static int responseCallForwards(Parcel &p, void *response, size_t responselen);
219 static int responseDataCallList(Parcel &p, void *response, size_t responselen);
220 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen);
221 static int responseRaw(Parcel &p, void *response, size_t responselen);
222 static int responseSsn(Parcel &p, void *response, size_t responselen);
223 static int responseSimStatus(Parcel &p, void *response, size_t responselen);
224 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen);
225 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen);
226 static int responseCdmaSms(Parcel &p, void *response, size_t responselen);
227 static int responseCellList(Parcel &p, void *response, size_t responselen);
228 static int responseCdmaInformationRecords(Parcel &p,void *response, size_t responselen);
229 static int responseRilSignalStrength(Parcel &p,void *response, size_t responselen);
230 static int responseCallRing(Parcel &p, void *response, size_t responselen);
231 static int responseCdmaSignalInfoRecord(Parcel &p,void *response, size_t responselen);
232 static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen);
234 extern "C" const char * requestToString(int request);
235 extern "C" const char * failCauseToString(RIL_Errno);
236 extern "C" const char * callStateToString(RIL_CallState);
237 extern "C" const char * radioStateToString(RIL_RadioState);
240 extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
244 static UserCallbackInfo * internalRequestTimedCallback
245 (RIL_TimedCallback callback, void *param,
246 const struct timeval *relativeTime);
248 /** Index == requestNumber */
249 static CommandInfo s_commands[] = {
250 #include "ril_commands.h"
253 static UnsolResponseInfo s_unsolResponses[] = {
254 #include "ril_unsol_commands.h"
259 strdupReadString(Parcel &p) {
263 s16 = p.readString16Inplace(&stringlen);
265 return strndup16to8(s16, stringlen);
268 static void writeStringToParcel(Parcel &p, const char *s) {
271 s16 = strdup8to16(s, &s16_len);
272 p.writeString16(s16, s16_len);
278 memsetString (char *s) {
280 memset (s, 0, strlen(s));
284 void nullParcelReleaseFunction (const uint8_t* data, size_t dataSize,
285 const size_t* objects, size_t objectsSize,
287 // do nothing -- the data reference lives longer than the Parcel object
291 * To be called from dispatch thread
292 * Issue a single local request, ensuring that the response
293 * is not sent back up to the command process
296 issueLocalRequest(int request, void *data, int len) {
300 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
303 pRI->token = 0xffffffff; // token is not used in this context
304 pRI->pCI = &(s_commands[request]);
306 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
309 pRI->p_next = s_pendingRequests;
310 s_pendingRequests = pRI;
312 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
315 LOGD("C[locl]> %s", requestToString(request));
317 s_callbacks.onRequest(request, data, len, pRI);
323 processCommandBuffer(void *buffer, size_t buflen) {
331 p.setData((uint8_t *) buffer, buflen);
333 // status checked at end
334 status = p.readInt32(&request);
335 status = p.readInt32 (&token);
337 if (status != NO_ERROR) {
338 LOGE("invalid request block");
342 if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
343 LOGE("unsupported request code %d token %d", request, token);
344 // FIXME this should perhaps return a response
349 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
352 pRI->pCI = &(s_commands[request]);
354 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
357 pRI->p_next = s_pendingRequests;
358 s_pendingRequests = pRI;
360 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
363 /* sLastDispatchedToken = token; */
365 pRI->pCI->dispatchFunction(p, pRI);
371 invalidCommandBlock (RequestInfo *pRI) {
372 LOGE("invalid command block for token %d request %s",
373 pRI->token, requestToString(pRI->pCI->requestNumber));
376 /** Callee expects NULL */
378 dispatchVoid (Parcel& p, RequestInfo *pRI) {
380 printRequest(pRI->token, pRI->pCI->requestNumber);
381 s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);
384 /** Callee expects const char * */
386 dispatchString (Parcel& p, RequestInfo *pRI) {
390 char *string8 = NULL;
392 string8 = strdupReadString(p);
395 appendPrintBuf("%s%s", printBuf, string8);
397 printRequest(pRI->token, pRI->pCI->requestNumber);
399 s_callbacks.onRequest(pRI->pCI->requestNumber, string8,
400 sizeof(char *), pRI);
403 memsetString(string8);
409 invalidCommandBlock(pRI);
413 /** Callee expects const char ** */
415 dispatchStrings (Parcel &p, RequestInfo *pRI) {
416 int32_t countStrings;
421 status = p.readInt32 (&countStrings);
423 if (status != NO_ERROR) {
428 if (countStrings == 0) {
429 // just some non-null pointer
430 pStrings = (char **)alloca(sizeof(char *));
432 } else if (((int)countStrings) == -1) {
436 datalen = sizeof(char *) * countStrings;
438 pStrings = (char **)alloca(datalen);
440 for (int i = 0 ; i < countStrings ; i++) {
441 pStrings[i] = strdupReadString(p);
442 appendPrintBuf("%s%s,", printBuf, pStrings[i]);
447 printRequest(pRI->token, pRI->pCI->requestNumber);
449 s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI);
451 if (pStrings != NULL) {
452 for (int i = 0 ; i < countStrings ; i++) {
454 memsetString (pStrings[i]);
460 memset(pStrings, 0, datalen);
466 invalidCommandBlock(pRI);
470 /** Callee expects const int * */
472 dispatchInts (Parcel &p, RequestInfo *pRI) {
478 status = p.readInt32 (&count);
480 if (status != NO_ERROR || count == 0) {
484 datalen = sizeof(int) * count;
485 pInts = (int *)alloca(datalen);
488 for (int i = 0 ; i < count ; i++) {
491 status = p.readInt32(&t);
493 appendPrintBuf("%s%d,", printBuf, t);
495 if (status != NO_ERROR) {
501 printRequest(pRI->token, pRI->pCI->requestNumber);
503 s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts),
507 memset(pInts, 0, datalen);
512 invalidCommandBlock(pRI);
518 * Callee expects const RIL_SMS_WriteArgs *
524 dispatchSmsWrite (Parcel &p, RequestInfo *pRI) {
525 RIL_SMS_WriteArgs args;
529 memset (&args, 0, sizeof(args));
531 status = p.readInt32(&t);
532 args.status = (int)t;
534 args.pdu = strdupReadString(p);
536 if (status != NO_ERROR || args.pdu == NULL) {
540 args.smsc = strdupReadString(p);
543 appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status,
544 (char*)args.pdu, (char*)args.smsc);
546 printRequest(pRI->token, pRI->pCI->requestNumber);
548 s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI);
551 memsetString (args.pdu);
557 memset(&args, 0, sizeof(args));
562 invalidCommandBlock(pRI);
567 * Callee expects const RIL_Dial *
573 dispatchDial (Parcel &p, RequestInfo *pRI) {
575 RIL_UUS_Info uusInfo;
581 memset (&dial, 0, sizeof(dial));
583 dial.address = strdupReadString(p);
585 status = p.readInt32(&t);
588 if (status != NO_ERROR || dial.address == NULL) {
592 if (s_callbacks.version < 3) { // Remove when partners upgrade to version 3
594 sizeOfDial = sizeof(dial) - sizeof(RIL_UUS_Info *);
596 status = p.readInt32(&uusPresent);
598 if (status != NO_ERROR) {
602 if (uusPresent == 0) {
607 memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
609 status = p.readInt32(&t);
610 uusInfo.uusType = (RIL_UUS_Type) t;
612 status = p.readInt32(&t);
613 uusInfo.uusDcs = (RIL_UUS_DCS) t;
615 status = p.readInt32(&len);
616 if (status != NO_ERROR) {
620 // The java code writes -1 for null arrays
621 if (((int) len) == -1) {
622 uusInfo.uusData = NULL;
625 uusInfo.uusData = (char*) p.readInplace(len);
628 uusInfo.uusLength = len;
629 dial.uusInfo = &uusInfo;
631 sizeOfDial = sizeof(dial);
635 appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir);
637 appendPrintBuf("%s,uusType=%d,uusDcs=%d,uusLen=%d", printBuf,
638 dial.uusInfo->uusType, dial.uusInfo->uusDcs,
639 dial.uusInfo->uusLength);
642 printRequest(pRI->token, pRI->pCI->requestNumber);
644 s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI);
647 memsetString (dial.address);
653 memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
654 memset(&dial, 0, sizeof(dial));
659 invalidCommandBlock(pRI);
664 * Callee expects const RIL_SIM_IO *
675 dispatchSIM_IO (Parcel &p, RequestInfo *pRI) {
685 memset (&simIO, 0, sizeof(simIO));
687 // note we only check status at the end
689 status = p.readInt32(&t);
690 simIO.v6.command = (int)t;
692 status = p.readInt32(&t);
693 simIO.v6.fileid = (int)t;
695 simIO.v6.path = strdupReadString(p);
697 status = p.readInt32(&t);
698 simIO.v6.p1 = (int)t;
700 status = p.readInt32(&t);
701 simIO.v6.p2 = (int)t;
703 status = p.readInt32(&t);
704 simIO.v6.p3 = (int)t;
706 simIO.v6.data = strdupReadString(p);
707 simIO.v6.pin2 = strdupReadString(p);
708 simIO.v6.aidPtr = strdupReadString(p);
711 appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s,aid=%s", printBuf,
712 simIO.v6.command, simIO.v6.fileid, (char*)simIO.v6.path,
713 simIO.v6.p1, simIO.v6.p2, simIO.v6.p3,
714 (char*)simIO.v6.data, (char*)simIO.v6.pin2, simIO.v6.aidPtr);
716 printRequest(pRI->token, pRI->pCI->requestNumber);
718 if (status != NO_ERROR) {
722 size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6);
723 s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, size, pRI);
726 memsetString (simIO.v6.path);
727 memsetString (simIO.v6.data);
728 memsetString (simIO.v6.pin2);
729 memsetString (simIO.v6.aidPtr);
732 free (simIO.v6.path);
733 free (simIO.v6.data);
734 free (simIO.v6.pin2);
735 free (simIO.v6.aidPtr);
738 memset(&simIO, 0, sizeof(simIO));
743 invalidCommandBlock(pRI);
748 * Callee expects const RIL_CallForwardInfo *
750 * int32_t status/action
752 * int32_t serviceCode
754 * String number (0 length -> null)
755 * int32_t timeSeconds
758 dispatchCallForward(Parcel &p, RequestInfo *pRI) {
759 RIL_CallForwardInfo cff;
763 memset (&cff, 0, sizeof(cff));
765 // note we only check status at the end
767 status = p.readInt32(&t);
770 status = p.readInt32(&t);
773 status = p.readInt32(&t);
774 cff.serviceClass = (int)t;
776 status = p.readInt32(&t);
779 cff.number = strdupReadString(p);
781 status = p.readInt32(&t);
782 cff.timeSeconds = (int)t;
784 if (status != NO_ERROR) {
788 // special case: number 0-length fields is null
790 if (cff.number != NULL && strlen (cff.number) == 0) {
795 appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf,
796 cff.status, cff.reason, cff.serviceClass, cff.toa,
797 (char*)cff.number, cff.timeSeconds);
799 printRequest(pRI->token, pRI->pCI->requestNumber);
801 s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI);
804 memsetString(cff.number);
810 memset(&cff, 0, sizeof(cff));
815 invalidCommandBlock(pRI);
821 dispatchRaw(Parcel &p, RequestInfo *pRI) {
826 status = p.readInt32(&len);
828 if (status != NO_ERROR) {
832 // The java code writes -1 for null arrays
833 if (((int)len) == -1) {
838 data = p.readInplace(len);
841 appendPrintBuf("%sraw_size=%d", printBuf, len);
843 printRequest(pRI->token, pRI->pCI->requestNumber);
845 s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI);
849 invalidCommandBlock(pRI);
854 dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
855 RIL_CDMA_SMS_Message rcsm;
862 memset(&rcsm, 0, sizeof(rcsm));
864 status = p.readInt32(&t);
865 rcsm.uTeleserviceID = (int) t;
867 status = p.read(&ut,sizeof(ut));
868 rcsm.bIsServicePresent = (uint8_t) ut;
870 status = p.readInt32(&t);
871 rcsm.uServicecategory = (int) t;
873 status = p.readInt32(&t);
874 rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
876 status = p.readInt32(&t);
877 rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
879 status = p.readInt32(&t);
880 rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
882 status = p.readInt32(&t);
883 rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
885 status = p.read(&ut,sizeof(ut));
886 rcsm.sAddress.number_of_digits= (uint8_t) ut;
888 digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
889 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
890 status = p.read(&ut,sizeof(ut));
891 rcsm.sAddress.digits[digitCount] = (uint8_t) ut;
894 status = p.readInt32(&t);
895 rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
897 status = p.read(&ut,sizeof(ut));
898 rcsm.sSubAddress.odd = (uint8_t) ut;
900 status = p.read(&ut,sizeof(ut));
901 rcsm.sSubAddress.number_of_digits = (uint8_t) ut;
903 digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
904 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
905 status = p.read(&ut,sizeof(ut));
906 rcsm.sSubAddress.digits[digitCount] = (uint8_t) ut;
909 status = p.readInt32(&t);
910 rcsm.uBearerDataLen = (int) t;
912 digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
913 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
914 status = p.read(&ut, sizeof(ut));
915 rcsm.aBearerData[digitCount] = (uint8_t) ut;
918 if (status != NO_ERROR) {
923 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
924 sAddress.digit_mode=%d, sAddress.Number_mode=%d, sAddress.number_type=%d, ",
925 printBuf, rcsm.uTeleserviceID,rcsm.bIsServicePresent,rcsm.uServicecategory,
926 rcsm.sAddress.digit_mode, rcsm.sAddress.number_mode,rcsm.sAddress.number_type);
929 printRequest(pRI->token, pRI->pCI->requestNumber);
931 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI);
934 memset(&rcsm, 0, sizeof(rcsm));
940 invalidCommandBlock(pRI);
945 dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) {
946 RIL_CDMA_SMS_Ack rcsa;
951 memset(&rcsa, 0, sizeof(rcsa));
953 status = p.readInt32(&t);
954 rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t;
956 status = p.readInt32(&t);
957 rcsa.uSMSCauseCode = (int) t;
959 if (status != NO_ERROR) {
964 appendPrintBuf("%suErrorClass=%d, uTLStatus=%d, ",
965 printBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode);
968 printRequest(pRI->token, pRI->pCI->requestNumber);
970 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI);
973 memset(&rcsa, 0, sizeof(rcsa));
979 invalidCommandBlock(pRI);
984 dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI) {
989 status = p.readInt32(&num);
990 if (status != NO_ERROR) {
994 RIL_GSM_BroadcastSmsConfigInfo gsmBci[num];
995 RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num];
998 for (int i = 0 ; i < num ; i++ ) {
999 gsmBciPtrs[i] = &gsmBci[i];
1001 status = p.readInt32(&t);
1002 gsmBci[i].fromServiceId = (int) t;
1004 status = p.readInt32(&t);
1005 gsmBci[i].toServiceId = (int) t;
1007 status = p.readInt32(&t);
1008 gsmBci[i].fromCodeScheme = (int) t;
1010 status = p.readInt32(&t);
1011 gsmBci[i].toCodeScheme = (int) t;
1013 status = p.readInt32(&t);
1014 gsmBci[i].selected = (uint8_t) t;
1016 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId =%d, \
1017 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", printBuf, i,
1018 gsmBci[i].fromServiceId, gsmBci[i].toServiceId,
1019 gsmBci[i].fromCodeScheme, gsmBci[i].toCodeScheme,
1020 gsmBci[i].selected);
1024 if (status != NO_ERROR) {
1028 s_callbacks.onRequest(pRI->pCI->requestNumber,
1030 num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *),
1034 memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo));
1035 memset(gsmBciPtrs, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *));
1041 invalidCommandBlock(pRI);
1046 dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1051 status = p.readInt32(&num);
1052 if (status != NO_ERROR) {
1056 RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num];
1057 RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num];
1060 for (int i = 0 ; i < num ; i++ ) {
1061 cdmaBciPtrs[i] = &cdmaBci[i];
1063 status = p.readInt32(&t);
1064 cdmaBci[i].service_category = (int) t;
1066 status = p.readInt32(&t);
1067 cdmaBci[i].language = (int) t;
1069 status = p.readInt32(&t);
1070 cdmaBci[i].selected = (uint8_t) t;
1072 appendPrintBuf("%s [%d: service_category=%d, language =%d, \
1073 entries.bSelected =%d]", printBuf, i, cdmaBci[i].service_category,
1074 cdmaBci[i].language, cdmaBci[i].selected);
1078 if (status != NO_ERROR) {
1082 s_callbacks.onRequest(pRI->pCI->requestNumber,
1084 num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *),
1088 memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo));
1089 memset(cdmaBciPtrs, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *));
1095 invalidCommandBlock(pRI);
1099 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) {
1100 RIL_CDMA_SMS_WriteArgs rcsw;
1107 memset(&rcsw, 0, sizeof(rcsw));
1109 status = p.readInt32(&t);
1112 status = p.readInt32(&t);
1113 rcsw.message.uTeleserviceID = (int) t;
1115 status = p.read(&uct,sizeof(uct));
1116 rcsw.message.bIsServicePresent = (uint8_t) uct;
1118 status = p.readInt32(&t);
1119 rcsw.message.uServicecategory = (int) t;
1121 status = p.readInt32(&t);
1122 rcsw.message.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
1124 status = p.readInt32(&t);
1125 rcsw.message.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
1127 status = p.readInt32(&t);
1128 rcsw.message.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
1130 status = p.readInt32(&t);
1131 rcsw.message.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
1133 status = p.read(&uct,sizeof(uct));
1134 rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
1136 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
1137 status = p.read(&uct,sizeof(uct));
1138 rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
1141 status = p.readInt32(&t);
1142 rcsw.message.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
1144 status = p.read(&uct,sizeof(uct));
1145 rcsw.message.sSubAddress.odd = (uint8_t) uct;
1147 status = p.read(&uct,sizeof(uct));
1148 rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
1150 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
1151 status = p.read(&uct,sizeof(uct));
1152 rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
1155 status = p.readInt32(&t);
1156 rcsw.message.uBearerDataLen = (int) t;
1158 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
1159 status = p.read(&uct, sizeof(uct));
1160 rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
1163 if (status != NO_ERROR) {
1168 appendPrintBuf("%sstatus=%d, message.uTeleserviceID=%d, message.bIsServicePresent=%d, \
1169 message.uServicecategory=%d, message.sAddress.digit_mode=%d, \
1170 message.sAddress.number_mode=%d, \
1171 message.sAddress.number_type=%d, ",
1172 printBuf, rcsw.status, rcsw.message.uTeleserviceID, rcsw.message.bIsServicePresent,
1173 rcsw.message.uServicecategory, rcsw.message.sAddress.digit_mode,
1174 rcsw.message.sAddress.number_mode,
1175 rcsw.message.sAddress.number_type);
1178 printRequest(pRI->token, pRI->pCI->requestNumber);
1180 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI);
1183 memset(&rcsw, 0, sizeof(rcsw));
1189 invalidCommandBlock(pRI);
1194 // For backwards compatibility in RIL_REQUEST_SETUP_DATA_CALL.
1195 // Version 4 of the RIL interface adds a new PDP type parameter to support
1196 // IPv6 and dual-stack PDP contexts. When dealing with a previous version of
1197 // RIL, remove the parameter from the request.
1198 static void dispatchDataCall(Parcel& p, RequestInfo *pRI) {
1199 // In RIL v3, REQUEST_SETUP_DATA_CALL takes 6 parameters.
1200 const int numParamsRilV3 = 6;
1202 // The first bytes of the RIL parcel contain the request number and the
1203 // serial number - see processCommandBuffer(). Copy them over too.
1204 int pos = p.dataPosition();
1206 int numParams = p.readInt32();
1207 if (s_callbacks.version < 4 && numParams > numParamsRilV3) {
1209 p2.appendFrom(&p, 0, pos);
1210 p2.writeInt32(numParamsRilV3);
1211 for(int i = 0; i < numParamsRilV3; i++) {
1212 p2.writeString16(p.readString16());
1214 p2.setDataPosition(pos);
1215 dispatchStrings(p2, pRI);
1217 p.setDataPosition(pos);
1218 dispatchStrings(p, pRI);
1223 blockingWrite(int fd, const void *buffer, size_t len) {
1224 size_t writeOffset = 0;
1225 const uint8_t *toWrite;
1227 toWrite = (const uint8_t *)buffer;
1229 while (writeOffset < len) {
1232 written = write (fd, toWrite + writeOffset,
1234 } while (written < 0 && errno == EINTR);
1237 writeOffset += written;
1238 } else { // written < 0
1239 LOGE ("RIL Response: unexpected error on write errno:%d", errno);
1249 sendResponseRaw (const void *data, size_t dataSize) {
1250 int fd = s_fdCommand;
1254 if (s_fdCommand < 0) {
1258 if (dataSize > MAX_COMMAND_BYTES) {
1259 LOGE("RIL: packet larger than %u (%u)",
1260 MAX_COMMAND_BYTES, (unsigned int )dataSize);
1265 pthread_mutex_lock(&s_writeMutex);
1267 header = htonl(dataSize);
1269 ret = blockingWrite(fd, (void *)&header, sizeof(header));
1272 pthread_mutex_unlock(&s_writeMutex);
1276 ret = blockingWrite(fd, data, dataSize);
1279 pthread_mutex_unlock(&s_writeMutex);
1283 pthread_mutex_unlock(&s_writeMutex);
1289 sendResponse (Parcel &p) {
1291 return sendResponseRaw(p.data(), p.dataSize());
1294 /** response is an int* pointing to an array of ints*/
1297 responseInts(Parcel &p, void *response, size_t responselen) {
1300 if (response == NULL && responselen != 0) {
1301 LOGE("invalid response: NULL");
1302 return RIL_ERRNO_INVALID_RESPONSE;
1304 if (responselen % sizeof(int) != 0) {
1305 LOGE("invalid response length %d expected multiple of %d\n",
1306 (int)responselen, (int)sizeof(int));
1307 return RIL_ERRNO_INVALID_RESPONSE;
1310 int *p_int = (int *) response;
1312 numInts = responselen / sizeof(int *);
1313 p.writeInt32 (numInts);
1317 for (int i = 0 ; i < numInts ; i++) {
1318 appendPrintBuf("%s%d,", printBuf, p_int[i]);
1319 p.writeInt32(p_int[i]);
1327 /** response is a char **, pointing to an array of char *'s
1328 The parcel will begin with the version */
1329 static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) {
1330 p.writeInt32(version);
1331 return responseStrings(p, response, responselen);
1334 /** response is a char **, pointing to an array of char *'s */
1335 static int responseStrings(Parcel &p, void *response, size_t responselen) {
1338 if (response == NULL && responselen != 0) {
1339 LOGE("invalid response: NULL");
1340 return RIL_ERRNO_INVALID_RESPONSE;
1342 if (responselen % sizeof(char *) != 0) {
1343 LOGE("invalid response length %d expected multiple of %d\n",
1344 (int)responselen, (int)sizeof(char *));
1345 return RIL_ERRNO_INVALID_RESPONSE;
1348 if (response == NULL) {
1351 char **p_cur = (char **) response;
1353 numStrings = responselen / sizeof(char *);
1354 p.writeInt32 (numStrings);
1358 for (int i = 0 ; i < numStrings ; i++) {
1359 appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
1360 writeStringToParcel (p, p_cur[i]);
1370 * NULL strings are accepted
1371 * FIXME currently ignores responselen
1373 static int responseString(Parcel &p, void *response, size_t responselen) {
1374 /* one string only */
1376 appendPrintBuf("%s%s", printBuf, (char*)response);
1379 writeStringToParcel(p, (const char *)response);
1384 static int responseVoid(Parcel &p, void *response, size_t responselen) {
1390 static int responseCallList(Parcel &p, void *response, size_t responselen) {
1393 if (response == NULL && responselen != 0) {
1394 LOGE("invalid response: NULL");
1395 return RIL_ERRNO_INVALID_RESPONSE;
1398 if (responselen % sizeof (RIL_Call *) != 0) {
1399 LOGE("invalid response length %d expected multiple of %d\n",
1400 (int)responselen, (int)sizeof (RIL_Call *));
1401 return RIL_ERRNO_INVALID_RESPONSE;
1405 /* number of call info's */
1406 num = responselen / sizeof(RIL_Call *);
1409 for (int i = 0 ; i < num ; i++) {
1410 RIL_Call *p_cur = ((RIL_Call **) response)[i];
1411 /* each call info */
1412 p.writeInt32(p_cur->state);
1413 p.writeInt32(p_cur->index);
1414 p.writeInt32(p_cur->toa);
1415 p.writeInt32(p_cur->isMpty);
1416 p.writeInt32(p_cur->isMT);
1417 p.writeInt32(p_cur->als);
1418 p.writeInt32(p_cur->isVoice);
1419 p.writeInt32(p_cur->isVoicePrivacy);
1420 writeStringToParcel(p, p_cur->number);
1421 p.writeInt32(p_cur->numberPresentation);
1422 writeStringToParcel(p, p_cur->name);
1423 p.writeInt32(p_cur->namePresentation);
1424 // Remove when partners upgrade to version 3
1425 if ((s_callbacks.version < 3) || (p_cur->uusInfo == NULL || p_cur->uusInfo->uusData == NULL)) {
1426 p.writeInt32(0); /* UUS Information is absent */
1428 RIL_UUS_Info *uusInfo = p_cur->uusInfo;
1429 p.writeInt32(1); /* UUS Information is present */
1430 p.writeInt32(uusInfo->uusType);
1431 p.writeInt32(uusInfo->uusDcs);
1432 p.writeInt32(uusInfo->uusLength);
1433 p.write(uusInfo->uusData, uusInfo->uusLength);
1435 appendPrintBuf("%s[id=%d,%s,toa=%d,",
1438 callStateToString(p_cur->state),
1440 appendPrintBuf("%s%s,%s,als=%d,%s,%s,",
1442 (p_cur->isMpty)?"conf":"norm",
1443 (p_cur->isMT)?"mt":"mo",
1445 (p_cur->isVoice)?"voc":"nonvoc",
1446 (p_cur->isVoicePrivacy)?"evp":"noevp");
1447 appendPrintBuf("%s%s,cli=%d,name='%s',%d]",
1450 p_cur->numberPresentation,
1452 p_cur->namePresentation);
1460 static int responseSMS(Parcel &p, void *response, size_t responselen) {
1461 if (response == NULL) {
1462 LOGE("invalid response: NULL");
1463 return RIL_ERRNO_INVALID_RESPONSE;
1466 if (responselen != sizeof (RIL_SMS_Response) ) {
1467 LOGE("invalid response length %d expected %d",
1468 (int)responselen, (int)sizeof (RIL_SMS_Response));
1469 return RIL_ERRNO_INVALID_RESPONSE;
1472 RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response;
1474 p.writeInt32(p_cur->messageRef);
1475 writeStringToParcel(p, p_cur->ackPDU);
1476 p.writeInt32(p_cur->errorCode);
1479 appendPrintBuf("%s%d,%s,%d", printBuf, p_cur->messageRef,
1480 (char*)p_cur->ackPDU, p_cur->errorCode);
1486 static int responseDataCallListV4(Parcel &p, void *response, size_t responselen)
1488 if (response == NULL && responselen != 0) {
1489 LOGE("invalid response: NULL");
1490 return RIL_ERRNO_INVALID_RESPONSE;
1493 if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) {
1494 LOGE("invalid response length %d expected multiple of %d",
1495 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v4));
1496 return RIL_ERRNO_INVALID_RESPONSE;
1499 int num = responselen / sizeof(RIL_Data_Call_Response_v4);
1502 RIL_Data_Call_Response_v4 *p_cur = (RIL_Data_Call_Response_v4 *) response;
1505 for (i = 0; i < num; i++) {
1506 p.writeInt32(p_cur[i].cid);
1507 p.writeInt32(p_cur[i].active);
1508 writeStringToParcel(p, p_cur[i].type);
1509 // apn is not used, so don't send.
1510 writeStringToParcel(p, p_cur[i].address);
1511 appendPrintBuf("%s[cid=%d,%s,%s,%s],", printBuf,
1513 (p_cur[i].active==0)?"down":"up",
1514 (char*)p_cur[i].type,
1515 (char*)p_cur[i].address);
1523 static int responseDataCallList(Parcel &p, void *response, size_t responselen)
1526 p.writeInt32(s_callbacks.version);
1528 if (s_callbacks.version < 5) {
1529 return responseDataCallListV4(p, response, responselen);
1531 if (response == NULL && responselen != 0) {
1532 LOGE("invalid response: NULL");
1533 return RIL_ERRNO_INVALID_RESPONSE;
1536 if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
1537 LOGE("invalid response length %d expected multiple of %d",
1538 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
1539 return RIL_ERRNO_INVALID_RESPONSE;
1542 int num = responselen / sizeof(RIL_Data_Call_Response_v6);
1545 RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
1548 for (i = 0; i < num; i++) {
1549 p.writeInt32((int)p_cur[i].status);
1550 p.writeInt32(p_cur[i].suggestedRetryTime);
1551 p.writeInt32(p_cur[i].cid);
1552 p.writeInt32(p_cur[i].active);
1553 writeStringToParcel(p, p_cur[i].type);
1554 writeStringToParcel(p, p_cur[i].ifname);
1555 writeStringToParcel(p, p_cur[i].addresses);
1556 writeStringToParcel(p, p_cur[i].dnses);
1557 writeStringToParcel(p, p_cur[i].gateways);
1558 appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%d,%s,%s,%s],", printBuf,
1560 p_cur[i].suggestedRetryTime,
1562 (p_cur[i].active==0)?"down":"up",
1563 (char*)p_cur[i].ifname,
1564 (char*)p_cur[i].addresses,
1565 (char*)p_cur[i].dnses,
1566 (char*)p_cur[i].gateways);
1575 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen)
1577 if (s_callbacks.version < 5) {
1578 return responseStringsWithVersion(s_callbacks.version, p, response, responselen);
1580 return responseDataCallList(p, response, responselen);
1584 static int responseRaw(Parcel &p, void *response, size_t responselen) {
1585 if (response == NULL && responselen != 0) {
1586 LOGE("invalid response: NULL with responselen != 0");
1587 return RIL_ERRNO_INVALID_RESPONSE;
1590 // The java code reads -1 size as null byte array
1591 if (response == NULL) {
1594 p.writeInt32(responselen);
1595 p.write(response, responselen);
1602 static int responseSIM_IO(Parcel &p, void *response, size_t responselen) {
1603 if (response == NULL) {
1604 LOGE("invalid response: NULL");
1605 return RIL_ERRNO_INVALID_RESPONSE;
1608 if (responselen != sizeof (RIL_SIM_IO_Response) ) {
1609 LOGE("invalid response length was %d expected %d",
1610 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
1611 return RIL_ERRNO_INVALID_RESPONSE;
1614 RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response;
1615 p.writeInt32(p_cur->sw1);
1616 p.writeInt32(p_cur->sw2);
1617 writeStringToParcel(p, p_cur->simResponse);
1620 appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2,
1621 (char*)p_cur->simResponse);
1628 static int responseCallForwards(Parcel &p, void *response, size_t responselen) {
1631 if (response == NULL && responselen != 0) {
1632 LOGE("invalid response: NULL");
1633 return RIL_ERRNO_INVALID_RESPONSE;
1636 if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
1637 LOGE("invalid response length %d expected multiple of %d",
1638 (int)responselen, (int)sizeof(RIL_CallForwardInfo *));
1639 return RIL_ERRNO_INVALID_RESPONSE;
1642 /* number of call info's */
1643 num = responselen / sizeof(RIL_CallForwardInfo *);
1647 for (int i = 0 ; i < num ; i++) {
1648 RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i];
1650 p.writeInt32(p_cur->status);
1651 p.writeInt32(p_cur->reason);
1652 p.writeInt32(p_cur->serviceClass);
1653 p.writeInt32(p_cur->toa);
1654 writeStringToParcel(p, p_cur->number);
1655 p.writeInt32(p_cur->timeSeconds);
1656 appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
1657 (p_cur->status==1)?"enable":"disable",
1658 p_cur->reason, p_cur->serviceClass, p_cur->toa,
1659 (char*)p_cur->number,
1660 p_cur->timeSeconds);
1668 static int responseSsn(Parcel &p, void *response, size_t responselen) {
1669 if (response == NULL) {
1670 LOGE("invalid response: NULL");
1671 return RIL_ERRNO_INVALID_RESPONSE;
1674 if (responselen != sizeof(RIL_SuppSvcNotification)) {
1675 LOGE("invalid response length was %d expected %d",
1676 (int)responselen, (int)sizeof (RIL_SuppSvcNotification));
1677 return RIL_ERRNO_INVALID_RESPONSE;
1680 RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response;
1681 p.writeInt32(p_cur->notificationType);
1682 p.writeInt32(p_cur->code);
1683 p.writeInt32(p_cur->index);
1684 p.writeInt32(p_cur->type);
1685 writeStringToParcel(p, p_cur->number);
1688 appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf,
1689 (p_cur->notificationType==0)?"mo":"mt",
1690 p_cur->code, p_cur->index, p_cur->type,
1691 (char*)p_cur->number);
1697 static int responseCellList(Parcel &p, void *response, size_t responselen) {
1700 if (response == NULL && responselen != 0) {
1701 LOGE("invalid response: NULL");
1702 return RIL_ERRNO_INVALID_RESPONSE;
1705 if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
1706 LOGE("invalid response length %d expected multiple of %d\n",
1707 (int)responselen, (int)sizeof (RIL_NeighboringCell *));
1708 return RIL_ERRNO_INVALID_RESPONSE;
1712 /* number of records */
1713 num = responselen / sizeof(RIL_NeighboringCell *);
1716 for (int i = 0 ; i < num ; i++) {
1717 RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i];
1719 p.writeInt32(p_cur->rssi);
1720 writeStringToParcel (p, p_cur->cid);
1722 appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf,
1723 p_cur->cid, p_cur->rssi);
1732 * Marshall the signalInfoRecord into the parcel if it exists.
1734 static void marshallSignalInfoRecord(Parcel &p,
1735 RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) {
1736 p.writeInt32(p_signalInfoRecord.isPresent);
1737 p.writeInt32(p_signalInfoRecord.signalType);
1738 p.writeInt32(p_signalInfoRecord.alertPitch);
1739 p.writeInt32(p_signalInfoRecord.signal);
1742 static int responseCdmaInformationRecords(Parcel &p,
1743 void *response, size_t responselen) {
1745 char* string8 = NULL;
1747 RIL_CDMA_InformationRecord *infoRec;
1749 if (response == NULL && responselen != 0) {
1750 LOGE("invalid response: NULL");
1751 return RIL_ERRNO_INVALID_RESPONSE;
1754 if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
1755 LOGE("invalid response length %d expected multiple of %d\n",
1756 (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
1757 return RIL_ERRNO_INVALID_RESPONSE;
1760 RIL_CDMA_InformationRecords *p_cur =
1761 (RIL_CDMA_InformationRecords *) response;
1762 num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
1767 for (int i = 0 ; i < num ; i++) {
1768 infoRec = &p_cur->infoRec[i];
1769 p.writeInt32(infoRec->name);
1770 switch (infoRec->name) {
1771 case RIL_CDMA_DISPLAY_INFO_REC:
1772 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC:
1773 if (infoRec->rec.display.alpha_len >
1774 CDMA_ALPHA_INFO_BUFFER_LENGTH) {
1775 LOGE("invalid display info response length %d \
1776 expected not more than %d\n",
1777 (int)infoRec->rec.display.alpha_len,
1778 CDMA_ALPHA_INFO_BUFFER_LENGTH);
1779 return RIL_ERRNO_INVALID_RESPONSE;
1781 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
1783 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
1784 string8[i] = infoRec->rec.display.alpha_buf[i];
1786 string8[(int)infoRec->rec.display.alpha_len] = '\0';
1787 writeStringToParcel(p, (const char*)string8);
1791 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
1792 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
1793 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC:
1794 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
1795 LOGE("invalid display info response length %d \
1796 expected not more than %d\n",
1797 (int)infoRec->rec.number.len,
1798 CDMA_NUMBER_INFO_BUFFER_LENGTH);
1799 return RIL_ERRNO_INVALID_RESPONSE;
1801 string8 = (char*) malloc((infoRec->rec.number.len + 1)
1803 for (int i = 0 ; i < infoRec->rec.number.len; i++) {
1804 string8[i] = infoRec->rec.number.buf[i];
1806 string8[(int)infoRec->rec.number.len] = '\0';
1807 writeStringToParcel(p, (const char*)string8);
1810 p.writeInt32(infoRec->rec.number.number_type);
1811 p.writeInt32(infoRec->rec.number.number_plan);
1812 p.writeInt32(infoRec->rec.number.pi);
1813 p.writeInt32(infoRec->rec.number.si);
1815 case RIL_CDMA_SIGNAL_INFO_REC:
1816 p.writeInt32(infoRec->rec.signal.isPresent);
1817 p.writeInt32(infoRec->rec.signal.signalType);
1818 p.writeInt32(infoRec->rec.signal.alertPitch);
1819 p.writeInt32(infoRec->rec.signal.signal);
1821 appendPrintBuf("%sisPresent=%X, signalType=%X, \
1822 alertPitch=%X, signal=%X, ",
1823 printBuf, (int)infoRec->rec.signal.isPresent,
1824 (int)infoRec->rec.signal.signalType,
1825 (int)infoRec->rec.signal.alertPitch,
1826 (int)infoRec->rec.signal.signal);
1829 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC:
1830 if (infoRec->rec.redir.redirectingNumber.len >
1831 CDMA_NUMBER_INFO_BUFFER_LENGTH) {
1832 LOGE("invalid display info response length %d \
1833 expected not more than %d\n",
1834 (int)infoRec->rec.redir.redirectingNumber.len,
1835 CDMA_NUMBER_INFO_BUFFER_LENGTH);
1836 return RIL_ERRNO_INVALID_RESPONSE;
1838 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
1839 .len + 1) * sizeof(char) );
1841 i < infoRec->rec.redir.redirectingNumber.len;
1843 string8[i] = infoRec->rec.redir.redirectingNumber.buf[i];
1845 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
1846 writeStringToParcel(p, (const char*)string8);
1849 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type);
1850 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan);
1851 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi);
1852 p.writeInt32(infoRec->rec.redir.redirectingNumber.si);
1853 p.writeInt32(infoRec->rec.redir.redirectingReason);
1855 case RIL_CDMA_LINE_CONTROL_INFO_REC:
1856 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded);
1857 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle);
1858 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse);
1859 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1861 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \
1862 lineCtrlToggle=%d, lineCtrlReverse=%d, \
1863 lineCtrlPowerDenial=%d, ", printBuf,
1864 (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded,
1865 (int)infoRec->rec.lineCtrl.lineCtrlToggle,
1866 (int)infoRec->rec.lineCtrl.lineCtrlReverse,
1867 (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1870 case RIL_CDMA_T53_CLIR_INFO_REC:
1871 p.writeInt32((int)(infoRec->rec.clir.cause));
1873 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause);
1876 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC:
1877 p.writeInt32(infoRec->rec.audioCtrl.upLink);
1878 p.writeInt32(infoRec->rec.audioCtrl.downLink);
1880 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf,
1881 infoRec->rec.audioCtrl.upLink,
1882 infoRec->rec.audioCtrl.downLink);
1885 case RIL_CDMA_T53_RELEASE_INFO_REC:
1886 // TODO(Moto): See David Krause, he has the answer:)
1887 LOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE");
1888 return RIL_ERRNO_INVALID_RESPONSE;
1890 LOGE("Incorrect name value");
1891 return RIL_ERRNO_INVALID_RESPONSE;
1899 static int responseRilSignalStrength(Parcel &p,
1900 void *response, size_t responselen) {
1901 if (response == NULL && responselen != 0) {
1902 LOGE("invalid response: NULL");
1903 return RIL_ERRNO_INVALID_RESPONSE;
1906 if (responselen >= sizeof (RIL_SignalStrength_v5)) {
1907 RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response);
1909 p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
1910 p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
1911 p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
1912 p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
1913 p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
1914 p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
1915 p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
1916 if (responselen >= sizeof (RIL_SignalStrength_v6)) {
1917 p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
1918 p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
1919 p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
1920 p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
1921 p.writeInt32(p_cur->LTE_SignalStrength.cqi);
1923 memset(&p_cur->LTE_SignalStrength, sizeof (RIL_LTE_SignalStrength), 0);
1927 appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
1928 CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
1929 EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
1930 EVDO_SS.signalNoiseRatio=%d,\
1931 LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
1932 LTE_SS.rssnr=%d,LTE_SS.cqi=%d]",
1934 p_cur->GW_SignalStrength.signalStrength,
1935 p_cur->GW_SignalStrength.bitErrorRate,
1936 p_cur->CDMA_SignalStrength.dbm,
1937 p_cur->CDMA_SignalStrength.ecio,
1938 p_cur->EVDO_SignalStrength.dbm,
1939 p_cur->EVDO_SignalStrength.ecio,
1940 p_cur->EVDO_SignalStrength.signalNoiseRatio,
1941 p_cur->LTE_SignalStrength.signalStrength,
1942 p_cur->LTE_SignalStrength.rsrp,
1943 p_cur->LTE_SignalStrength.rsrq,
1944 p_cur->LTE_SignalStrength.rssnr,
1945 p_cur->LTE_SignalStrength.cqi);
1949 LOGE("invalid response length");
1950 return RIL_ERRNO_INVALID_RESPONSE;
1956 static int responseCallRing(Parcel &p, void *response, size_t responselen) {
1957 if ((response == NULL) || (responselen == 0)) {
1958 return responseVoid(p, response, responselen);
1960 return responseCdmaSignalInfoRecord(p, response, responselen);
1964 static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) {
1965 if (response == NULL || responselen == 0) {
1966 LOGE("invalid response: NULL");
1967 return RIL_ERRNO_INVALID_RESPONSE;
1970 if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) {
1971 LOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n",
1972 (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord));
1973 return RIL_ERRNO_INVALID_RESPONSE;
1978 RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response);
1979 marshallSignalInfoRecord(p, *p_cur);
1981 appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\
1993 static int responseCdmaCallWaiting(Parcel &p, void *response,
1994 size_t responselen) {
1995 if (response == NULL && responselen != 0) {
1996 LOGE("invalid response: NULL");
1997 return RIL_ERRNO_INVALID_RESPONSE;
2000 if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) {
2001 LOGW("Upgrade to ril version %d\n", RIL_VERSION);
2004 RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response);
2006 writeStringToParcel(p, p_cur->number);
2007 p.writeInt32(p_cur->numberPresentation);
2008 writeStringToParcel(p, p_cur->name);
2009 marshallSignalInfoRecord(p, p_cur->signalInfoRecord);
2011 if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
2012 p.writeInt32(p_cur->number_type);
2013 p.writeInt32(p_cur->number_plan);
2020 appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\
2021 signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\
2022 signal=%d,number_type=%d,number_plan=%d]",
2025 p_cur->numberPresentation,
2027 p_cur->signalInfoRecord.isPresent,
2028 p_cur->signalInfoRecord.signalType,
2029 p_cur->signalInfoRecord.alertPitch,
2030 p_cur->signalInfoRecord.signal,
2032 p_cur->number_plan);
2038 static void triggerEvLoop() {
2040 if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
2041 /* trigger event loop to wakeup. No reason to do this,
2042 * if we're in the event loop thread */
2044 ret = write (s_fdWakeupWrite, " ", 1);
2045 } while (ret < 0 && errno == EINTR);
2049 static void rilEventAddWakeup(struct ril_event *ev) {
2054 static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) {
2055 p.writeInt32(num_apps);
2057 for (int i = 0; i < num_apps; i++) {
2058 p.writeInt32(appStatus[i].app_type);
2059 p.writeInt32(appStatus[i].app_state);
2060 p.writeInt32(appStatus[i].perso_substate);
2061 writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr));
2062 writeStringToParcel(p, (const char*)
2063 (appStatus[i].app_label_ptr));
2064 p.writeInt32(appStatus[i].pin1_replaced);
2065 p.writeInt32(appStatus[i].pin1);
2066 p.writeInt32(appStatus[i].pin2);
2067 appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\
2068 aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],",
2070 appStatus[i].app_type,
2071 appStatus[i].app_state,
2072 appStatus[i].perso_substate,
2073 appStatus[i].aid_ptr,
2074 appStatus[i].app_label_ptr,
2075 appStatus[i].pin1_replaced,
2082 static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
2085 if (response == NULL && responselen != 0) {
2086 LOGE("invalid response: NULL");
2087 return RIL_ERRNO_INVALID_RESPONSE;
2090 if (responselen == sizeof (RIL_CardStatus_v6)) {
2091 RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
2093 p.writeInt32(p_cur->card_state);
2094 p.writeInt32(p_cur->universal_pin_state);
2095 p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2096 p.writeInt32(p_cur->cdma_subscription_app_index);
2097 p.writeInt32(p_cur->ims_subscription_app_index);
2099 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
2100 } else if (responselen == sizeof (RIL_CardStatus_v5)) {
2101 RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
2103 p.writeInt32(p_cur->card_state);
2104 p.writeInt32(p_cur->universal_pin_state);
2105 p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2106 p.writeInt32(p_cur->cdma_subscription_app_index);
2109 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
2111 LOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
2112 return RIL_ERRNO_INVALID_RESPONSE;
2118 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2119 int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
2123 RIL_GSM_BroadcastSmsConfigInfo **p_cur =
2124 (RIL_GSM_BroadcastSmsConfigInfo **) response;
2125 for (int i = 0; i < num; i++) {
2126 p.writeInt32(p_cur[i]->fromServiceId);
2127 p.writeInt32(p_cur[i]->toServiceId);
2128 p.writeInt32(p_cur[i]->fromCodeScheme);
2129 p.writeInt32(p_cur[i]->toCodeScheme);
2130 p.writeInt32(p_cur[i]->selected);
2132 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \
2133 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]",
2134 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId,
2135 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme,
2136 p_cur[i]->selected);
2143 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2144 RIL_CDMA_BroadcastSmsConfigInfo **p_cur =
2145 (RIL_CDMA_BroadcastSmsConfigInfo **) response;
2147 int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *);
2151 for (int i = 0 ; i < num ; i++ ) {
2152 p.writeInt32(p_cur[i]->service_category);
2153 p.writeInt32(p_cur[i]->language);
2154 p.writeInt32(p_cur[i]->selected);
2156 appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \
2158 printBuf, i, p_cur[i]->service_category, p_cur[i]->language,
2159 p_cur[i]->selected);
2166 static int responseCdmaSms(Parcel &p, void *response, size_t responselen) {
2173 LOGD("Inside responseCdmaSms");
2175 if (response == NULL && responselen != 0) {
2176 LOGE("invalid response: NULL");
2177 return RIL_ERRNO_INVALID_RESPONSE;
2180 if (responselen != sizeof(RIL_CDMA_SMS_Message)) {
2181 LOGE("invalid response length was %d expected %d",
2182 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message));
2183 return RIL_ERRNO_INVALID_RESPONSE;
2186 RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response;
2187 p.writeInt32(p_cur->uTeleserviceID);
2188 p.write(&(p_cur->bIsServicePresent),sizeof(uct));
2189 p.writeInt32(p_cur->uServicecategory);
2190 p.writeInt32(p_cur->sAddress.digit_mode);
2191 p.writeInt32(p_cur->sAddress.number_mode);
2192 p.writeInt32(p_cur->sAddress.number_type);
2193 p.writeInt32(p_cur->sAddress.number_plan);
2194 p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct));
2195 digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
2196 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2197 p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct));
2200 p.writeInt32(p_cur->sSubAddress.subaddressType);
2201 p.write(&(p_cur->sSubAddress.odd),sizeof(uct));
2202 p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct));
2203 digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
2204 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2205 p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct));
2208 digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
2209 p.writeInt32(p_cur->uBearerDataLen);
2210 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2211 p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct));
2215 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
2216 sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ",
2217 printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory,
2218 p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type);
2225 * A write on the wakeup fd is done just to pop us out of select()
2226 * We empty the buffer here and then ril_event will reset the timers on the
2229 static void processWakeupCallback(int fd, short flags, void *param) {
2233 LOGV("processWakeupCallback");
2235 /* empty our wakeup socket out */
2237 ret = read(s_fdWakeupRead, &buff, sizeof(buff));
2238 } while (ret > 0 || (ret < 0 && errno == EINTR));
2241 static void onCommandsSocketClosed() {
2245 /* mark pending requests as "cancelled" so we dont report responses */
2247 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
2250 p_cur = s_pendingRequests;
2252 for (p_cur = s_pendingRequests
2254 ; p_cur = p_cur->p_next
2256 p_cur->cancelled = 1;
2259 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
2263 static void processCommandsCallback(int fd, short flags, void *param) {
2269 assert(fd == s_fdCommand);
2271 p_rs = (RecordStream *)param;
2274 /* loop until EAGAIN/EINTR, end of stream, or other error */
2275 ret = record_stream_get_next(p_rs, &p_record, &recordlen);
2277 if (ret == 0 && p_record == NULL) {
2280 } else if (ret < 0) {
2282 } else if (ret == 0) { /* && p_record != NULL */
2283 processCommandBuffer(p_record, recordlen);
2287 if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {
2288 /* fatal error or end-of-stream */
2290 LOGE("error on reading command socket errno:%d\n", errno);
2292 LOGW("EOS. Closing command socket.");
2298 ril_event_del(&s_commands_event);
2300 record_stream_free(p_rs);
2302 /* start listening for new connections again */
2303 rilEventAddWakeup(&s_listen_event);
2305 onCommandsSocketClosed();
2310 static void onNewCommandConnect() {
2311 // Inform we are connected and the ril version
2312 int rilVer = s_callbacks.version;
2313 RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED,
2314 &rilVer, sizeof(rilVer));
2316 // implicit radio state changed
2317 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
2320 // Send last NITZ time data, in case it was missed
2321 if (s_lastNITZTimeData != NULL) {
2322 sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
2324 free(s_lastNITZTimeData);
2325 s_lastNITZTimeData = NULL;
2328 // Get version string
2329 if (s_callbacks.getVersion != NULL) {
2330 const char *version;
2331 version = s_callbacks.getVersion();
2332 LOGI("RIL Daemon version: %s\n", version);
2334 property_set(PROPERTY_RIL_IMPL, version);
2336 LOGI("RIL Daemon version: unavailable\n");
2337 property_set(PROPERTY_RIL_IMPL, "unavailable");
2342 static void listenCallback (int fd, short flags, void *param) {
2345 int is_phone_socket;
2348 struct sockaddr_un peeraddr;
2349 socklen_t socklen = sizeof (peeraddr);
2352 socklen_t szCreds = sizeof(creds);
2354 struct passwd *pwd = NULL;
2356 assert (s_fdCommand < 0);
2357 assert (fd == s_fdListen);
2359 s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
2361 if (s_fdCommand < 0 ) {
2362 LOGE("Error on accept() errno:%d", errno);
2363 /* start listening for new connections again */
2364 rilEventAddWakeup(&s_listen_event);
2368 /* check the credential of the other side and only accept socket from
2372 is_phone_socket = 0;
2374 err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
2376 if (err == 0 && szCreds > 0) {
2378 pwd = getpwuid(creds.uid);
2380 if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
2381 is_phone_socket = 1;
2383 LOGE("RILD can't accept socket from process %s", pwd->pw_name);
2386 LOGE("Error on getpwuid() errno: %d", errno);
2389 LOGD("Error on getsockopt() errno: %d", errno);
2392 if ( !is_phone_socket ) {
2393 LOGE("RILD must accept socket from %s", PHONE_PROCESS);
2398 onCommandsSocketClosed();
2400 /* start listening for new connections again */
2401 rilEventAddWakeup(&s_listen_event);
2406 ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
2409 LOGE ("Error setting O_NONBLOCK errno:%d", errno);
2412 LOGI("libril: new connection");
2414 p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
2416 ril_event_set (&s_commands_event, s_fdCommand, 1,
2417 processCommandsCallback, p_rs);
2419 rilEventAddWakeup (&s_commands_event);
2421 onNewCommandConnect();
2424 static void freeDebugCallbackArgs(int number, char **args) {
2425 for (int i = 0; i < number; i++) {
2426 if (args[i] != NULL) {
2433 static void debugCallback (int fd, short flags, void *param) {
2434 int acceptFD, option;
2435 struct sockaddr_un peeraddr;
2436 socklen_t socklen = sizeof (peeraddr);
2438 unsigned int qxdm_data[6];
2439 const char *deactData[1] = {"1"};
2442 int hangupData[1] = {1};
2446 acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen);
2449 LOGE ("error accepting on debug port: %d\n", errno);
2453 if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
2454 LOGE ("error reading on socket: number of Args: \n");
2457 args = (char **) malloc(sizeof(char*) * number);
2459 for (int i = 0; i < number; i++) {
2461 if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
2462 LOGE ("error reading on socket: Len of Args: \n");
2463 freeDebugCallbackArgs(i, args);
2467 args[i] = (char *) malloc((sizeof(char) * len) + 1);
2468 if (recv(acceptFD, args[i], sizeof(char) * len, 0)
2469 != (int)sizeof(char) * len) {
2470 LOGE ("error reading on socket: Args[%d] \n", i);
2471 freeDebugCallbackArgs(i, args);
2474 char * buf = args[i];
2478 switch (atoi(args[0])) {
2480 LOGI ("Connection on debug port: issuing reset.");
2481 issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
2484 LOGI ("Connection on debug port: issuing radio power off.");
2486 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2492 LOGI ("Debug port: issuing unsolicited voice network change.");
2493 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
2497 LOGI ("Debug port: QXDM log enable.");
2498 qxdm_data[0] = 65536; // head.func_tag
2499 qxdm_data[1] = 16; // head.len
2500 qxdm_data[2] = 1; // mode: 1 for 'start logging'
2501 qxdm_data[3] = 32; // log_file_size: 32megabytes
2502 qxdm_data[4] = 0; // log_mask
2503 qxdm_data[5] = 8; // log_max_fileindex
2504 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2508 LOGI ("Debug port: QXDM log disable.");
2509 qxdm_data[0] = 65536;
2511 qxdm_data[2] = 0; // mode: 0 for 'stop logging'
2515 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2519 LOGI("Debug port: Radio On");
2521 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2523 // Set network selection automatic.
2524 issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
2527 LOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]);
2528 actData[0] = args[1];
2529 issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData,
2533 LOGI("Debug port: Deactivate Data Call");
2534 issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
2538 LOGI("Debug port: Dial Call");
2540 dialData.address = args[1];
2541 issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
2544 LOGI("Debug port: Answer Call");
2545 issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
2548 LOGI("Debug port: End Call");
2549 issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
2550 sizeof(hangupData));
2553 LOGE ("Invalid request");
2556 freeDebugCallbackArgs(number, args);
2561 static void userTimerCallback (int fd, short flags, void *param) {
2562 UserCallbackInfo *p_info;
2564 p_info = (UserCallbackInfo *)param;
2566 p_info->p_callback(p_info->userParam);
2569 // FIXME generalize this...there should be a cancel mechanism
2570 if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) {
2571 s_last_wake_timeout_info = NULL;
2579 eventLoop(void *param) {
2585 pthread_mutex_lock(&s_startupMutex);
2588 pthread_cond_broadcast(&s_startupCond);
2590 pthread_mutex_unlock(&s_startupMutex);
2592 ret = pipe(filedes);
2595 LOGE("Error in pipe() errno:%d", errno);
2599 s_fdWakeupRead = filedes[0];
2600 s_fdWakeupWrite = filedes[1];
2602 fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
2604 ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
2605 processWakeupCallback, NULL);
2607 rilEventAddWakeup (&s_wakeupfd_event);
2609 // Only returns on error
2611 LOGE ("error in event_loop_base errno:%d", errno);
2617 RIL_startEventLoop(void) {
2619 pthread_attr_t attr;
2621 /* spin up eventLoop thread and wait for it to get started */
2623 pthread_mutex_lock(&s_startupMutex);
2625 pthread_attr_init (&attr);
2626 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2627 ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
2629 while (s_started == 0) {
2630 pthread_cond_wait(&s_startupCond, &s_startupMutex);
2633 pthread_mutex_unlock(&s_startupMutex);
2636 LOGE("Failed to create dispatch thread errno:%d", errno);
2641 // Used for testing purpose only.
2642 extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) {
2643 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2647 RIL_register (const RIL_RadioFunctions *callbacks) {
2651 if (callbacks == NULL) {
2652 LOGE("RIL_register: RIL_RadioFunctions * null");
2655 if (callbacks->version < RIL_VERSION_MIN) {
2656 LOGE("RIL_register: version %d is to old, min version is %d",
2657 callbacks->version, RIL_VERSION_MIN);
2660 if (callbacks->version > RIL_VERSION) {
2661 LOGE("RIL_register: version %d is too new, max version is %d",
2662 callbacks->version, RIL_VERSION);
2665 LOGE("RIL_register: RIL version %d", callbacks->version);
2667 if (s_registerCalled > 0) {
2668 LOGE("RIL_register has been called more than once. "
2669 "Subsequent call ignored");
2673 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2675 s_registerCalled = 1;
2677 // Little self-check
2679 for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
2680 assert(i == s_commands[i].requestNumber);
2683 for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) {
2684 assert(i + RIL_UNSOL_RESPONSE_BASE
2685 == s_unsolResponses[i].requestNumber);
2688 // New rild impl calls RIL_startEventLoop() first
2689 // old standalone impl wants it here.
2691 if (s_started == 0) {
2692 RIL_startEventLoop();
2695 // start listen socket
2698 ret = socket_local_server (SOCKET_NAME_RIL,
2699 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
2702 LOGE("Unable to bind socket errno:%d", errno);
2708 s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
2709 if (s_fdListen < 0) {
2710 LOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
2714 ret = listen(s_fdListen, 4);
2717 LOGE("Failed to listen on control socket '%d': %s",
2718 s_fdListen, strerror(errno));
2724 /* note: non-persistent so we can accept only one connection at a time */
2725 ril_event_set (&s_listen_event, s_fdListen, false,
2726 listenCallback, NULL);
2728 rilEventAddWakeup (&s_listen_event);
2731 // start debug interface socket
2733 s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
2734 if (s_fdDebug < 0) {
2735 LOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
2739 ret = listen(s_fdDebug, 4);
2742 LOGE("Failed to listen on ril debug socket '%d': %s",
2743 s_fdDebug, strerror(errno));
2747 ril_event_set (&s_debug_event, s_fdDebug, true,
2748 debugCallback, NULL);
2750 rilEventAddWakeup (&s_debug_event);
2756 checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
2763 pthread_mutex_lock(&s_pendingRequestsMutex);
2765 for(RequestInfo **ppCur = &s_pendingRequests
2767 ; ppCur = &((*ppCur)->p_next)
2769 if (pRI == *ppCur) {
2772 *ppCur = (*ppCur)->p_next;
2777 pthread_mutex_unlock(&s_pendingRequestsMutex);
2784 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
2789 pRI = (RequestInfo *)t;
2791 if (!checkAndDequeueRequestInfo(pRI)) {
2792 LOGE ("RIL_onRequestComplete: invalid RIL_Token");
2796 if (pRI->local > 0) {
2797 // Locally issued command...void only!
2798 // response does not go back up the command socket
2799 LOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));
2804 appendPrintBuf("[%04d]< %s",
2805 pRI->token, requestToString(pRI->pCI->requestNumber));
2807 if (pRI->cancelled == 0) {
2810 p.writeInt32 (RESPONSE_SOLICITED);
2811 p.writeInt32 (pRI->token);
2812 errorOffset = p.dataPosition();
2816 if (response != NULL) {
2817 // there is a response payload, no matter success or not.
2818 ret = pRI->pCI->responseFunction(p, response, responselen);
2820 /* if an error occurred, rewind and mark it */
2822 p.setDataPosition(errorOffset);
2827 if (e != RIL_E_SUCCESS) {
2828 appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
2831 if (s_fdCommand < 0) {
2832 LOGD ("RIL onRequestComplete: Command channel closed");
2843 grabPartialWakeLock() {
2844 acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
2849 release_wake_lock(ANDROID_WAKE_LOCK_NAME);
2853 * Timer callback to put us back to sleep before the default timeout
2856 wakeTimeoutCallback (void *param) {
2857 // We're using "param != NULL" as a cancellation mechanism
2858 if (param == NULL) {
2859 //LOGD("wakeTimeout: releasing wake lock");
2863 //LOGD("wakeTimeout: releasing wake lock CANCELLED");
2868 void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
2871 int unsolResponseIndex;
2873 int64_t timeReceived = 0;
2874 bool shouldScheduleTimeout = false;
2876 if (s_registerCalled == 0) {
2877 // Ignore RIL_onUnsolicitedResponse before RIL_register
2878 LOGW("RIL_onUnsolicitedResponse called before RIL_register");
2882 unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
2884 if ((unsolResponseIndex < 0)
2885 || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) {
2886 LOGE("unsupported unsolicited response code %d", unsolResponse);
2890 // Grab a wake lock if needed for this reponse,
2891 // as we exit we'll either release it immediately
2892 // or set a timer to release it later.
2893 switch (s_unsolResponses[unsolResponseIndex].wakeType) {
2895 grabPartialWakeLock();
2896 shouldScheduleTimeout = true;
2901 // No wake lock is grabed so don't set timeout
2902 shouldScheduleTimeout = false;
2906 // Mark the time this was received, doing this
2907 // after grabing the wakelock incase getting
2908 // the elapsedRealTime might cause us to goto
2910 if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
2911 timeReceived = elapsedRealtime();
2914 appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
2918 p.writeInt32 (RESPONSE_UNSOLICITED);
2919 p.writeInt32 (unsolResponse);
2921 ret = s_unsolResponses[unsolResponseIndex]
2922 .responseFunction(p, data, datalen);
2924 // Problem with the response. Don't continue;
2928 // some things get more payload
2929 switch(unsolResponse) {
2930 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
2931 p.writeInt32(s_callbacks.onStateRequest());
2932 appendPrintBuf("%s {%s}", printBuf,
2933 radioStateToString(s_callbacks.onStateRequest()));
2937 case RIL_UNSOL_NITZ_TIME_RECEIVED:
2938 // Store the time that this was received so the
2939 // handler of this message can account for
2940 // the time it takes to arrive and process. In
2941 // particular the system has been known to sleep
2942 // before this message can be processed.
2943 p.writeInt64(timeReceived);
2947 ret = sendResponse(p);
2948 if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
2950 // Unfortunately, NITZ time is not poll/update like everything
2951 // else in the system. So, if the upstream client isn't connected,
2952 // keep a copy of the last NITZ response (with receive time noted
2953 // above) around so we can deliver it when it is connected
2955 if (s_lastNITZTimeData != NULL) {
2956 free (s_lastNITZTimeData);
2957 s_lastNITZTimeData = NULL;
2960 s_lastNITZTimeData = malloc(p.dataSize());
2961 s_lastNITZTimeDataSize = p.dataSize();
2962 memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
2965 // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
2966 // FIXME The java code should handshake here to release wake lock
2968 if (shouldScheduleTimeout) {
2969 // Cancel the previous request
2970 if (s_last_wake_timeout_info != NULL) {
2971 s_last_wake_timeout_info->userParam = (void *)1;
2974 s_last_wake_timeout_info
2975 = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
2976 &TIMEVAL_WAKE_TIMEOUT);
2983 if (shouldScheduleTimeout) {
2988 /** FIXME generalize this if you track UserCAllbackInfo, clear it
2989 when the callback occurs
2991 static UserCallbackInfo *
2992 internalRequestTimedCallback (RIL_TimedCallback callback, void *param,
2993 const struct timeval *relativeTime)
2995 struct timeval myRelativeTime;
2996 UserCallbackInfo *p_info;
2998 p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
3000 p_info->p_callback = callback;
3001 p_info->userParam = param;
3003 if (relativeTime == NULL) {
3004 /* treat null parameter as a 0 relative time */
3005 memset (&myRelativeTime, 0, sizeof(myRelativeTime));
3007 /* FIXME I think event_add's tv param is really const anyway */
3008 memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));
3011 ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);
3013 ril_timer_add(&(p_info->event), &myRelativeTime);
3021 RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,
3022 const struct timeval *relativeTime) {
3023 internalRequestTimedCallback (callback, param, relativeTime);
3027 failCauseToString(RIL_Errno e) {
3029 case RIL_E_SUCCESS: return "E_SUCCESS";
3030 case RIL_E_RADIO_NOT_AVAILABLE: return "E_RAIDO_NOT_AVAILABLE";
3031 case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE";
3032 case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT";
3033 case RIL_E_SIM_PIN2: return "E_SIM_PIN2";
3034 case RIL_E_SIM_PUK2: return "E_SIM_PUK2";
3035 case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED";
3036 case RIL_E_CANCELLED: return "E_CANCELLED";
3037 case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL";
3038 case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
3039 case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY";
3040 case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT";
3041 case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME";
3042 #ifdef FEATURE_MULTIMODE_ANDROID
3043 case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
3044 case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
3046 default: return "<unknown error>";
3051 radioStateToString(RIL_RadioState s) {
3053 case RADIO_STATE_OFF: return "RADIO_OFF";
3054 case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE";
3055 case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY";
3056 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT";
3057 case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY";
3058 case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY";
3059 case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY";
3060 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT";
3061 case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY";
3062 case RADIO_STATE_NV_READY:return"RADIO_NV_READY";
3063 default: return "<unknown state>";
3068 callStateToString(RIL_CallState s) {
3070 case RIL_CALL_ACTIVE : return "ACTIVE";
3071 case RIL_CALL_HOLDING: return "HOLDING";
3072 case RIL_CALL_DIALING: return "DIALING";
3073 case RIL_CALL_ALERTING: return "ALERTING";
3074 case RIL_CALL_INCOMING: return "INCOMING";
3075 case RIL_CALL_WAITING: return "WAITING";
3076 default: return "<unknown state>";
3081 requestToString(int request) {
3083 cat libs/telephony/ril_commands.h \
3084 | egrep "^ *{RIL_" \
3085 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
3088 cat libs/telephony/ril_unsol_commands.h \
3089 | egrep "^ *{RIL_" \
3090 | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
3094 case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
3095 case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
3096 case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
3097 case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
3098 case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
3099 case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
3100 case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
3101 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
3102 case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
3103 case RIL_REQUEST_DIAL: return "DIAL";
3104 case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
3105 case RIL_REQUEST_HANGUP: return "HANGUP";
3106 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
3107 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
3108 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
3109 case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
3110 case RIL_REQUEST_UDUB: return "UDUB";
3111 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
3112 case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
3113 case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
3114 case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
3115 case RIL_REQUEST_OPERATOR: return "OPERATOR";
3116 case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
3117 case RIL_REQUEST_DTMF: return "DTMF";
3118 case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
3119 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
3120 case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
3121 case RIL_REQUEST_SIM_IO: return "SIM_IO";
3122 case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
3123 case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
3124 case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
3125 case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
3126 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
3127 case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
3128 case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
3129 case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
3130 case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
3131 case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
3132 case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
3133 case RIL_REQUEST_ANSWER: return "ANSWER";
3134 case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
3135 case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
3136 case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
3137 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
3138 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
3139 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
3140 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
3141 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
3142 case RIL_REQUEST_DTMF_START: return "DTMF_START";
3143 case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
3144 case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
3145 case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
3146 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
3147 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
3148 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
3149 case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
3150 case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
3151 case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
3152 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
3153 case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
3154 case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
3155 case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
3156 case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
3157 case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
3158 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
3159 case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
3160 case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
3161 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
3162 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
3163 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
3164 case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
3165 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
3166 case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
3167 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
3168 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
3169 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
3170 case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
3171 case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
3172 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
3173 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
3174 case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
3175 case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
3176 case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
3177 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
3178 case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
3179 case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
3180 case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
3181 case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
3182 case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
3183 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
3184 case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
3185 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
3186 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
3187 case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
3188 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
3189 case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
3190 case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
3191 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
3192 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
3193 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
3194 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
3195 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
3196 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
3197 case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
3198 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
3199 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
3200 case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
3201 case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
3202 case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
3203 case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
3204 case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
3205 case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
3206 case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
3207 case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
3208 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
3209 case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
3210 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
3211 case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
3212 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
3213 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
3214 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
3215 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
3216 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
3217 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
3218 case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
3219 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
3220 case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
3221 case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
3222 case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
3223 case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
3224 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
3225 case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
3226 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
3227 case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
3228 default: return "<unknown request>";
3232 } /* namespace android */