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].cid);
1551 p.writeInt32(p_cur[i].active);
1552 writeStringToParcel(p, p_cur[i].type);
1553 writeStringToParcel(p, p_cur[i].ifname);
1554 writeStringToParcel(p, p_cur[i].addresses);
1555 writeStringToParcel(p, p_cur[i].dnses);
1556 writeStringToParcel(p, p_cur[i].gateways);
1557 appendPrintBuf("%s[status=%d,cid=%d,%s,%d,%s,%s,%s],", printBuf,
1560 (p_cur[i].active==0)?"down":"up",
1561 (char*)p_cur[i].ifname,
1562 (char*)p_cur[i].addresses,
1563 (char*)p_cur[i].dnses,
1564 (char*)p_cur[i].gateways);
1573 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen)
1575 if (s_callbacks.version < 5) {
1576 return responseStringsWithVersion(s_callbacks.version, p, response, responselen);
1578 return responseDataCallList(p, response, responselen);
1582 static int responseRaw(Parcel &p, void *response, size_t responselen) {
1583 if (response == NULL && responselen != 0) {
1584 LOGE("invalid response: NULL with responselen != 0");
1585 return RIL_ERRNO_INVALID_RESPONSE;
1588 // The java code reads -1 size as null byte array
1589 if (response == NULL) {
1592 p.writeInt32(responselen);
1593 p.write(response, responselen);
1600 static int responseSIM_IO(Parcel &p, void *response, size_t responselen) {
1601 if (response == NULL) {
1602 LOGE("invalid response: NULL");
1603 return RIL_ERRNO_INVALID_RESPONSE;
1606 if (responselen != sizeof (RIL_SIM_IO_Response) ) {
1607 LOGE("invalid response length was %d expected %d",
1608 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
1609 return RIL_ERRNO_INVALID_RESPONSE;
1612 RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response;
1613 p.writeInt32(p_cur->sw1);
1614 p.writeInt32(p_cur->sw2);
1615 writeStringToParcel(p, p_cur->simResponse);
1618 appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2,
1619 (char*)p_cur->simResponse);
1626 static int responseCallForwards(Parcel &p, void *response, size_t responselen) {
1629 if (response == NULL && responselen != 0) {
1630 LOGE("invalid response: NULL");
1631 return RIL_ERRNO_INVALID_RESPONSE;
1634 if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
1635 LOGE("invalid response length %d expected multiple of %d",
1636 (int)responselen, (int)sizeof(RIL_CallForwardInfo *));
1637 return RIL_ERRNO_INVALID_RESPONSE;
1640 /* number of call info's */
1641 num = responselen / sizeof(RIL_CallForwardInfo *);
1645 for (int i = 0 ; i < num ; i++) {
1646 RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i];
1648 p.writeInt32(p_cur->status);
1649 p.writeInt32(p_cur->reason);
1650 p.writeInt32(p_cur->serviceClass);
1651 p.writeInt32(p_cur->toa);
1652 writeStringToParcel(p, p_cur->number);
1653 p.writeInt32(p_cur->timeSeconds);
1654 appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
1655 (p_cur->status==1)?"enable":"disable",
1656 p_cur->reason, p_cur->serviceClass, p_cur->toa,
1657 (char*)p_cur->number,
1658 p_cur->timeSeconds);
1666 static int responseSsn(Parcel &p, void *response, size_t responselen) {
1667 if (response == NULL) {
1668 LOGE("invalid response: NULL");
1669 return RIL_ERRNO_INVALID_RESPONSE;
1672 if (responselen != sizeof(RIL_SuppSvcNotification)) {
1673 LOGE("invalid response length was %d expected %d",
1674 (int)responselen, (int)sizeof (RIL_SuppSvcNotification));
1675 return RIL_ERRNO_INVALID_RESPONSE;
1678 RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response;
1679 p.writeInt32(p_cur->notificationType);
1680 p.writeInt32(p_cur->code);
1681 p.writeInt32(p_cur->index);
1682 p.writeInt32(p_cur->type);
1683 writeStringToParcel(p, p_cur->number);
1686 appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf,
1687 (p_cur->notificationType==0)?"mo":"mt",
1688 p_cur->code, p_cur->index, p_cur->type,
1689 (char*)p_cur->number);
1695 static int responseCellList(Parcel &p, void *response, size_t responselen) {
1698 if (response == NULL && responselen != 0) {
1699 LOGE("invalid response: NULL");
1700 return RIL_ERRNO_INVALID_RESPONSE;
1703 if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
1704 LOGE("invalid response length %d expected multiple of %d\n",
1705 (int)responselen, (int)sizeof (RIL_NeighboringCell *));
1706 return RIL_ERRNO_INVALID_RESPONSE;
1710 /* number of records */
1711 num = responselen / sizeof(RIL_NeighboringCell *);
1714 for (int i = 0 ; i < num ; i++) {
1715 RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i];
1717 p.writeInt32(p_cur->rssi);
1718 writeStringToParcel (p, p_cur->cid);
1720 appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf,
1721 p_cur->cid, p_cur->rssi);
1730 * Marshall the signalInfoRecord into the parcel if it exists.
1732 static void marshallSignalInfoRecord(Parcel &p,
1733 RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) {
1734 p.writeInt32(p_signalInfoRecord.isPresent);
1735 p.writeInt32(p_signalInfoRecord.signalType);
1736 p.writeInt32(p_signalInfoRecord.alertPitch);
1737 p.writeInt32(p_signalInfoRecord.signal);
1740 static int responseCdmaInformationRecords(Parcel &p,
1741 void *response, size_t responselen) {
1743 char* string8 = NULL;
1745 RIL_CDMA_InformationRecord *infoRec;
1747 if (response == NULL && responselen != 0) {
1748 LOGE("invalid response: NULL");
1749 return RIL_ERRNO_INVALID_RESPONSE;
1752 if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
1753 LOGE("invalid response length %d expected multiple of %d\n",
1754 (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
1755 return RIL_ERRNO_INVALID_RESPONSE;
1758 RIL_CDMA_InformationRecords *p_cur =
1759 (RIL_CDMA_InformationRecords *) response;
1760 num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
1765 for (int i = 0 ; i < num ; i++) {
1766 infoRec = &p_cur->infoRec[i];
1767 p.writeInt32(infoRec->name);
1768 switch (infoRec->name) {
1769 case RIL_CDMA_DISPLAY_INFO_REC:
1770 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC:
1771 if (infoRec->rec.display.alpha_len >
1772 CDMA_ALPHA_INFO_BUFFER_LENGTH) {
1773 LOGE("invalid display info response length %d \
1774 expected not more than %d\n",
1775 (int)infoRec->rec.display.alpha_len,
1776 CDMA_ALPHA_INFO_BUFFER_LENGTH);
1777 return RIL_ERRNO_INVALID_RESPONSE;
1779 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
1781 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
1782 string8[i] = infoRec->rec.display.alpha_buf[i];
1784 string8[(int)infoRec->rec.display.alpha_len] = '\0';
1785 writeStringToParcel(p, (const char*)string8);
1789 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
1790 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
1791 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC:
1792 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
1793 LOGE("invalid display info response length %d \
1794 expected not more than %d\n",
1795 (int)infoRec->rec.number.len,
1796 CDMA_NUMBER_INFO_BUFFER_LENGTH);
1797 return RIL_ERRNO_INVALID_RESPONSE;
1799 string8 = (char*) malloc((infoRec->rec.number.len + 1)
1801 for (int i = 0 ; i < infoRec->rec.number.len; i++) {
1802 string8[i] = infoRec->rec.number.buf[i];
1804 string8[(int)infoRec->rec.number.len] = '\0';
1805 writeStringToParcel(p, (const char*)string8);
1808 p.writeInt32(infoRec->rec.number.number_type);
1809 p.writeInt32(infoRec->rec.number.number_plan);
1810 p.writeInt32(infoRec->rec.number.pi);
1811 p.writeInt32(infoRec->rec.number.si);
1813 case RIL_CDMA_SIGNAL_INFO_REC:
1814 p.writeInt32(infoRec->rec.signal.isPresent);
1815 p.writeInt32(infoRec->rec.signal.signalType);
1816 p.writeInt32(infoRec->rec.signal.alertPitch);
1817 p.writeInt32(infoRec->rec.signal.signal);
1819 appendPrintBuf("%sisPresent=%X, signalType=%X, \
1820 alertPitch=%X, signal=%X, ",
1821 printBuf, (int)infoRec->rec.signal.isPresent,
1822 (int)infoRec->rec.signal.signalType,
1823 (int)infoRec->rec.signal.alertPitch,
1824 (int)infoRec->rec.signal.signal);
1827 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC:
1828 if (infoRec->rec.redir.redirectingNumber.len >
1829 CDMA_NUMBER_INFO_BUFFER_LENGTH) {
1830 LOGE("invalid display info response length %d \
1831 expected not more than %d\n",
1832 (int)infoRec->rec.redir.redirectingNumber.len,
1833 CDMA_NUMBER_INFO_BUFFER_LENGTH);
1834 return RIL_ERRNO_INVALID_RESPONSE;
1836 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
1837 .len + 1) * sizeof(char) );
1839 i < infoRec->rec.redir.redirectingNumber.len;
1841 string8[i] = infoRec->rec.redir.redirectingNumber.buf[i];
1843 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
1844 writeStringToParcel(p, (const char*)string8);
1847 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type);
1848 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan);
1849 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi);
1850 p.writeInt32(infoRec->rec.redir.redirectingNumber.si);
1851 p.writeInt32(infoRec->rec.redir.redirectingReason);
1853 case RIL_CDMA_LINE_CONTROL_INFO_REC:
1854 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded);
1855 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle);
1856 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse);
1857 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1859 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \
1860 lineCtrlToggle=%d, lineCtrlReverse=%d, \
1861 lineCtrlPowerDenial=%d, ", printBuf,
1862 (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded,
1863 (int)infoRec->rec.lineCtrl.lineCtrlToggle,
1864 (int)infoRec->rec.lineCtrl.lineCtrlReverse,
1865 (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1868 case RIL_CDMA_T53_CLIR_INFO_REC:
1869 p.writeInt32((int)(infoRec->rec.clir.cause));
1871 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause);
1874 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC:
1875 p.writeInt32(infoRec->rec.audioCtrl.upLink);
1876 p.writeInt32(infoRec->rec.audioCtrl.downLink);
1878 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf,
1879 infoRec->rec.audioCtrl.upLink,
1880 infoRec->rec.audioCtrl.downLink);
1883 case RIL_CDMA_T53_RELEASE_INFO_REC:
1884 // TODO(Moto): See David Krause, he has the answer:)
1885 LOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE");
1886 return RIL_ERRNO_INVALID_RESPONSE;
1888 LOGE("Incorrect name value");
1889 return RIL_ERRNO_INVALID_RESPONSE;
1897 static int responseRilSignalStrength(Parcel &p,
1898 void *response, size_t responselen) {
1899 if (response == NULL && responselen != 0) {
1900 LOGE("invalid response: NULL");
1901 return RIL_ERRNO_INVALID_RESPONSE;
1904 if (responselen >= sizeof (RIL_SignalStrength_v5)) {
1905 RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response);
1907 p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
1908 p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
1909 p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
1910 p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
1911 p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
1912 p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
1913 p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
1914 if (responselen >= sizeof (RIL_SignalStrength_v6)) {
1915 p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
1916 p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
1917 p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
1918 p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
1919 p.writeInt32(p_cur->LTE_SignalStrength.cqi);
1921 memset(&p_cur->LTE_SignalStrength, sizeof (RIL_LTE_SignalStrength), 0);
1925 appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
1926 CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
1927 EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
1928 EVDO_SS.signalNoiseRatio=%d,\
1929 LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
1930 LTE_SS.rssnr=%d,LTE_SS.cqi=%d]",
1932 p_cur->GW_SignalStrength.signalStrength,
1933 p_cur->GW_SignalStrength.bitErrorRate,
1934 p_cur->CDMA_SignalStrength.dbm,
1935 p_cur->CDMA_SignalStrength.ecio,
1936 p_cur->EVDO_SignalStrength.dbm,
1937 p_cur->EVDO_SignalStrength.ecio,
1938 p_cur->EVDO_SignalStrength.signalNoiseRatio,
1939 p_cur->LTE_SignalStrength.signalStrength,
1940 p_cur->LTE_SignalStrength.rsrp,
1941 p_cur->LTE_SignalStrength.rsrq,
1942 p_cur->LTE_SignalStrength.rssnr,
1943 p_cur->LTE_SignalStrength.cqi);
1947 LOGE("invalid response length");
1948 return RIL_ERRNO_INVALID_RESPONSE;
1954 static int responseCallRing(Parcel &p, void *response, size_t responselen) {
1955 if ((response == NULL) || (responselen == 0)) {
1956 return responseVoid(p, response, responselen);
1958 return responseCdmaSignalInfoRecord(p, response, responselen);
1962 static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) {
1963 if (response == NULL || responselen == 0) {
1964 LOGE("invalid response: NULL");
1965 return RIL_ERRNO_INVALID_RESPONSE;
1968 if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) {
1969 LOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n",
1970 (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord));
1971 return RIL_ERRNO_INVALID_RESPONSE;
1976 RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response);
1977 marshallSignalInfoRecord(p, *p_cur);
1979 appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\
1991 static int responseCdmaCallWaiting(Parcel &p, void *response,
1992 size_t responselen) {
1993 if (response == NULL && responselen != 0) {
1994 LOGE("invalid response: NULL");
1995 return RIL_ERRNO_INVALID_RESPONSE;
1998 if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) {
1999 LOGW("Upgrade to ril version %d\n", RIL_VERSION);
2002 RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response);
2004 writeStringToParcel(p, p_cur->number);
2005 p.writeInt32(p_cur->numberPresentation);
2006 writeStringToParcel(p, p_cur->name);
2007 marshallSignalInfoRecord(p, p_cur->signalInfoRecord);
2009 if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
2010 p.writeInt32(p_cur->number_type);
2011 p.writeInt32(p_cur->number_plan);
2018 appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\
2019 signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\
2020 signal=%d,number_type=%d,number_plan=%d]",
2023 p_cur->numberPresentation,
2025 p_cur->signalInfoRecord.isPresent,
2026 p_cur->signalInfoRecord.signalType,
2027 p_cur->signalInfoRecord.alertPitch,
2028 p_cur->signalInfoRecord.signal,
2030 p_cur->number_plan);
2036 static void triggerEvLoop() {
2038 if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
2039 /* trigger event loop to wakeup. No reason to do this,
2040 * if we're in the event loop thread */
2042 ret = write (s_fdWakeupWrite, " ", 1);
2043 } while (ret < 0 && errno == EINTR);
2047 static void rilEventAddWakeup(struct ril_event *ev) {
2052 static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) {
2053 p.writeInt32(num_apps);
2055 for (int i = 0; i < num_apps; i++) {
2056 p.writeInt32(appStatus[i].app_type);
2057 p.writeInt32(appStatus[i].app_state);
2058 p.writeInt32(appStatus[i].perso_substate);
2059 writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr));
2060 writeStringToParcel(p, (const char*)
2061 (appStatus[i].app_label_ptr));
2062 p.writeInt32(appStatus[i].pin1_replaced);
2063 p.writeInt32(appStatus[i].pin1);
2064 p.writeInt32(appStatus[i].pin2);
2065 appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\
2066 aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],",
2068 appStatus[i].app_type,
2069 appStatus[i].app_state,
2070 appStatus[i].perso_substate,
2071 appStatus[i].aid_ptr,
2072 appStatus[i].app_label_ptr,
2073 appStatus[i].pin1_replaced,
2080 static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
2083 if (response == NULL && responselen != 0) {
2084 LOGE("invalid response: NULL");
2085 return RIL_ERRNO_INVALID_RESPONSE;
2088 if (responselen == sizeof (RIL_CardStatus_v6)) {
2089 RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
2091 p.writeInt32(p_cur->card_state);
2092 p.writeInt32(p_cur->universal_pin_state);
2093 p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2094 p.writeInt32(p_cur->cdma_subscription_app_index);
2095 p.writeInt32(p_cur->ims_subscription_app_index);
2097 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
2098 } else if (responselen == sizeof (RIL_CardStatus_v5)) {
2099 RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
2101 p.writeInt32(p_cur->card_state);
2102 p.writeInt32(p_cur->universal_pin_state);
2103 p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2104 p.writeInt32(p_cur->cdma_subscription_app_index);
2107 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
2109 LOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
2110 return RIL_ERRNO_INVALID_RESPONSE;
2116 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2117 int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
2121 RIL_GSM_BroadcastSmsConfigInfo **p_cur =
2122 (RIL_GSM_BroadcastSmsConfigInfo **) response;
2123 for (int i = 0; i < num; i++) {
2124 p.writeInt32(p_cur[i]->fromServiceId);
2125 p.writeInt32(p_cur[i]->toServiceId);
2126 p.writeInt32(p_cur[i]->fromCodeScheme);
2127 p.writeInt32(p_cur[i]->toCodeScheme);
2128 p.writeInt32(p_cur[i]->selected);
2130 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \
2131 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]",
2132 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId,
2133 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme,
2134 p_cur[i]->selected);
2141 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2142 RIL_CDMA_BroadcastSmsConfigInfo **p_cur =
2143 (RIL_CDMA_BroadcastSmsConfigInfo **) response;
2145 int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *);
2149 for (int i = 0 ; i < num ; i++ ) {
2150 p.writeInt32(p_cur[i]->service_category);
2151 p.writeInt32(p_cur[i]->language);
2152 p.writeInt32(p_cur[i]->selected);
2154 appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \
2156 printBuf, i, p_cur[i]->service_category, p_cur[i]->language,
2157 p_cur[i]->selected);
2164 static int responseCdmaSms(Parcel &p, void *response, size_t responselen) {
2171 LOGD("Inside responseCdmaSms");
2173 if (response == NULL && responselen != 0) {
2174 LOGE("invalid response: NULL");
2175 return RIL_ERRNO_INVALID_RESPONSE;
2178 if (responselen != sizeof(RIL_CDMA_SMS_Message)) {
2179 LOGE("invalid response length was %d expected %d",
2180 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message));
2181 return RIL_ERRNO_INVALID_RESPONSE;
2184 RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response;
2185 p.writeInt32(p_cur->uTeleserviceID);
2186 p.write(&(p_cur->bIsServicePresent),sizeof(uct));
2187 p.writeInt32(p_cur->uServicecategory);
2188 p.writeInt32(p_cur->sAddress.digit_mode);
2189 p.writeInt32(p_cur->sAddress.number_mode);
2190 p.writeInt32(p_cur->sAddress.number_type);
2191 p.writeInt32(p_cur->sAddress.number_plan);
2192 p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct));
2193 digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
2194 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2195 p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct));
2198 p.writeInt32(p_cur->sSubAddress.subaddressType);
2199 p.write(&(p_cur->sSubAddress.odd),sizeof(uct));
2200 p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct));
2201 digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
2202 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2203 p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct));
2206 digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
2207 p.writeInt32(p_cur->uBearerDataLen);
2208 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2209 p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct));
2213 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
2214 sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ",
2215 printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory,
2216 p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type);
2223 * A write on the wakeup fd is done just to pop us out of select()
2224 * We empty the buffer here and then ril_event will reset the timers on the
2227 static void processWakeupCallback(int fd, short flags, void *param) {
2231 LOGV("processWakeupCallback");
2233 /* empty our wakeup socket out */
2235 ret = read(s_fdWakeupRead, &buff, sizeof(buff));
2236 } while (ret > 0 || (ret < 0 && errno == EINTR));
2239 static void onCommandsSocketClosed() {
2243 /* mark pending requests as "cancelled" so we dont report responses */
2245 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
2248 p_cur = s_pendingRequests;
2250 for (p_cur = s_pendingRequests
2252 ; p_cur = p_cur->p_next
2254 p_cur->cancelled = 1;
2257 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
2261 static void processCommandsCallback(int fd, short flags, void *param) {
2267 assert(fd == s_fdCommand);
2269 p_rs = (RecordStream *)param;
2272 /* loop until EAGAIN/EINTR, end of stream, or other error */
2273 ret = record_stream_get_next(p_rs, &p_record, &recordlen);
2275 if (ret == 0 && p_record == NULL) {
2278 } else if (ret < 0) {
2280 } else if (ret == 0) { /* && p_record != NULL */
2281 processCommandBuffer(p_record, recordlen);
2285 if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {
2286 /* fatal error or end-of-stream */
2288 LOGE("error on reading command socket errno:%d\n", errno);
2290 LOGW("EOS. Closing command socket.");
2296 ril_event_del(&s_commands_event);
2298 record_stream_free(p_rs);
2300 /* start listening for new connections again */
2301 rilEventAddWakeup(&s_listen_event);
2303 onCommandsSocketClosed();
2308 static void onNewCommandConnect() {
2309 // Inform we are connected and the ril version
2310 int rilVer = s_callbacks.version;
2311 RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED,
2312 &rilVer, sizeof(rilVer));
2314 // implicit radio state changed
2315 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
2318 // Send last NITZ time data, in case it was missed
2319 if (s_lastNITZTimeData != NULL) {
2320 sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
2322 free(s_lastNITZTimeData);
2323 s_lastNITZTimeData = NULL;
2326 // Get version string
2327 if (s_callbacks.getVersion != NULL) {
2328 const char *version;
2329 version = s_callbacks.getVersion();
2330 LOGI("RIL Daemon version: %s\n", version);
2332 property_set(PROPERTY_RIL_IMPL, version);
2334 LOGI("RIL Daemon version: unavailable\n");
2335 property_set(PROPERTY_RIL_IMPL, "unavailable");
2340 static void listenCallback (int fd, short flags, void *param) {
2343 int is_phone_socket;
2346 struct sockaddr_un peeraddr;
2347 socklen_t socklen = sizeof (peeraddr);
2350 socklen_t szCreds = sizeof(creds);
2352 struct passwd *pwd = NULL;
2354 assert (s_fdCommand < 0);
2355 assert (fd == s_fdListen);
2357 s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
2359 if (s_fdCommand < 0 ) {
2360 LOGE("Error on accept() errno:%d", errno);
2361 /* start listening for new connections again */
2362 rilEventAddWakeup(&s_listen_event);
2366 /* check the credential of the other side and only accept socket from
2370 is_phone_socket = 0;
2372 err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
2374 if (err == 0 && szCreds > 0) {
2376 pwd = getpwuid(creds.uid);
2378 if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
2379 is_phone_socket = 1;
2381 LOGE("RILD can't accept socket from process %s", pwd->pw_name);
2384 LOGE("Error on getpwuid() errno: %d", errno);
2387 LOGD("Error on getsockopt() errno: %d", errno);
2390 if ( !is_phone_socket ) {
2391 LOGE("RILD must accept socket from %s", PHONE_PROCESS);
2396 onCommandsSocketClosed();
2398 /* start listening for new connections again */
2399 rilEventAddWakeup(&s_listen_event);
2404 ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
2407 LOGE ("Error setting O_NONBLOCK errno:%d", errno);
2410 LOGI("libril: new connection");
2412 p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
2414 ril_event_set (&s_commands_event, s_fdCommand, 1,
2415 processCommandsCallback, p_rs);
2417 rilEventAddWakeup (&s_commands_event);
2419 onNewCommandConnect();
2422 static void freeDebugCallbackArgs(int number, char **args) {
2423 for (int i = 0; i < number; i++) {
2424 if (args[i] != NULL) {
2431 static void debugCallback (int fd, short flags, void *param) {
2432 int acceptFD, option;
2433 struct sockaddr_un peeraddr;
2434 socklen_t socklen = sizeof (peeraddr);
2436 unsigned int qxdm_data[6];
2437 const char *deactData[1] = {"1"};
2440 int hangupData[1] = {1};
2444 acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen);
2447 LOGE ("error accepting on debug port: %d\n", errno);
2451 if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
2452 LOGE ("error reading on socket: number of Args: \n");
2455 args = (char **) malloc(sizeof(char*) * number);
2457 for (int i = 0; i < number; i++) {
2459 if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
2460 LOGE ("error reading on socket: Len of Args: \n");
2461 freeDebugCallbackArgs(i, args);
2465 args[i] = (char *) malloc((sizeof(char) * len) + 1);
2466 if (recv(acceptFD, args[i], sizeof(char) * len, 0)
2467 != (int)sizeof(char) * len) {
2468 LOGE ("error reading on socket: Args[%d] \n", i);
2469 freeDebugCallbackArgs(i, args);
2472 char * buf = args[i];
2476 switch (atoi(args[0])) {
2478 LOGI ("Connection on debug port: issuing reset.");
2479 issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
2482 LOGI ("Connection on debug port: issuing radio power off.");
2484 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2490 LOGI ("Debug port: issuing unsolicited voice network change.");
2491 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
2495 LOGI ("Debug port: QXDM log enable.");
2496 qxdm_data[0] = 65536; // head.func_tag
2497 qxdm_data[1] = 16; // head.len
2498 qxdm_data[2] = 1; // mode: 1 for 'start logging'
2499 qxdm_data[3] = 32; // log_file_size: 32megabytes
2500 qxdm_data[4] = 0; // log_mask
2501 qxdm_data[5] = 8; // log_max_fileindex
2502 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2506 LOGI ("Debug port: QXDM log disable.");
2507 qxdm_data[0] = 65536;
2509 qxdm_data[2] = 0; // mode: 0 for 'stop logging'
2513 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2517 LOGI("Debug port: Radio On");
2519 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2521 // Set network selection automatic.
2522 issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
2525 LOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]);
2526 actData[0] = args[1];
2527 issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData,
2531 LOGI("Debug port: Deactivate Data Call");
2532 issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
2536 LOGI("Debug port: Dial Call");
2538 dialData.address = args[1];
2539 issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
2542 LOGI("Debug port: Answer Call");
2543 issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
2546 LOGI("Debug port: End Call");
2547 issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
2548 sizeof(hangupData));
2551 LOGE ("Invalid request");
2554 freeDebugCallbackArgs(number, args);
2559 static void userTimerCallback (int fd, short flags, void *param) {
2560 UserCallbackInfo *p_info;
2562 p_info = (UserCallbackInfo *)param;
2564 p_info->p_callback(p_info->userParam);
2567 // FIXME generalize this...there should be a cancel mechanism
2568 if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) {
2569 s_last_wake_timeout_info = NULL;
2577 eventLoop(void *param) {
2583 pthread_mutex_lock(&s_startupMutex);
2586 pthread_cond_broadcast(&s_startupCond);
2588 pthread_mutex_unlock(&s_startupMutex);
2590 ret = pipe(filedes);
2593 LOGE("Error in pipe() errno:%d", errno);
2597 s_fdWakeupRead = filedes[0];
2598 s_fdWakeupWrite = filedes[1];
2600 fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
2602 ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
2603 processWakeupCallback, NULL);
2605 rilEventAddWakeup (&s_wakeupfd_event);
2607 // Only returns on error
2609 LOGE ("error in event_loop_base errno:%d", errno);
2615 RIL_startEventLoop(void) {
2617 pthread_attr_t attr;
2619 /* spin up eventLoop thread and wait for it to get started */
2621 pthread_mutex_lock(&s_startupMutex);
2623 pthread_attr_init (&attr);
2624 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2625 ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
2627 while (s_started == 0) {
2628 pthread_cond_wait(&s_startupCond, &s_startupMutex);
2631 pthread_mutex_unlock(&s_startupMutex);
2634 LOGE("Failed to create dispatch thread errno:%d", errno);
2639 // Used for testing purpose only.
2640 extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) {
2641 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2645 RIL_register (const RIL_RadioFunctions *callbacks) {
2649 if (callbacks == NULL) {
2650 LOGE("RIL_register: RIL_RadioFunctions * null");
2653 if (callbacks->version < RIL_VERSION_MIN) {
2654 LOGE("RIL_register: version %d is to old, min version is %d",
2655 callbacks->version, RIL_VERSION_MIN);
2658 if (callbacks->version > RIL_VERSION) {
2659 LOGE("RIL_register: version %d is too new, max version is %d",
2660 callbacks->version, RIL_VERSION);
2663 LOGE("RIL_register: RIL version %d", callbacks->version);
2665 if (s_registerCalled > 0) {
2666 LOGE("RIL_register has been called more than once. "
2667 "Subsequent call ignored");
2671 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2673 s_registerCalled = 1;
2675 // Little self-check
2677 for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
2678 assert(i == s_commands[i].requestNumber);
2681 for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) {
2682 assert(i + RIL_UNSOL_RESPONSE_BASE
2683 == s_unsolResponses[i].requestNumber);
2686 // New rild impl calls RIL_startEventLoop() first
2687 // old standalone impl wants it here.
2689 if (s_started == 0) {
2690 RIL_startEventLoop();
2693 // start listen socket
2696 ret = socket_local_server (SOCKET_NAME_RIL,
2697 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
2700 LOGE("Unable to bind socket errno:%d", errno);
2706 s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
2707 if (s_fdListen < 0) {
2708 LOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
2712 ret = listen(s_fdListen, 4);
2715 LOGE("Failed to listen on control socket '%d': %s",
2716 s_fdListen, strerror(errno));
2722 /* note: non-persistent so we can accept only one connection at a time */
2723 ril_event_set (&s_listen_event, s_fdListen, false,
2724 listenCallback, NULL);
2726 rilEventAddWakeup (&s_listen_event);
2729 // start debug interface socket
2731 s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
2732 if (s_fdDebug < 0) {
2733 LOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
2737 ret = listen(s_fdDebug, 4);
2740 LOGE("Failed to listen on ril debug socket '%d': %s",
2741 s_fdDebug, strerror(errno));
2745 ril_event_set (&s_debug_event, s_fdDebug, true,
2746 debugCallback, NULL);
2748 rilEventAddWakeup (&s_debug_event);
2754 checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
2761 pthread_mutex_lock(&s_pendingRequestsMutex);
2763 for(RequestInfo **ppCur = &s_pendingRequests
2765 ; ppCur = &((*ppCur)->p_next)
2767 if (pRI == *ppCur) {
2770 *ppCur = (*ppCur)->p_next;
2775 pthread_mutex_unlock(&s_pendingRequestsMutex);
2782 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
2787 pRI = (RequestInfo *)t;
2789 if (!checkAndDequeueRequestInfo(pRI)) {
2790 LOGE ("RIL_onRequestComplete: invalid RIL_Token");
2794 if (pRI->local > 0) {
2795 // Locally issued command...void only!
2796 // response does not go back up the command socket
2797 LOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));
2802 appendPrintBuf("[%04d]< %s",
2803 pRI->token, requestToString(pRI->pCI->requestNumber));
2805 if (pRI->cancelled == 0) {
2808 p.writeInt32 (RESPONSE_SOLICITED);
2809 p.writeInt32 (pRI->token);
2810 errorOffset = p.dataPosition();
2814 if (response != NULL) {
2815 // there is a response payload, no matter success or not.
2816 ret = pRI->pCI->responseFunction(p, response, responselen);
2818 /* if an error occurred, rewind and mark it */
2820 p.setDataPosition(errorOffset);
2825 if (e != RIL_E_SUCCESS) {
2826 appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
2829 if (s_fdCommand < 0) {
2830 LOGD ("RIL onRequestComplete: Command channel closed");
2841 grabPartialWakeLock() {
2842 acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
2847 release_wake_lock(ANDROID_WAKE_LOCK_NAME);
2851 * Timer callback to put us back to sleep before the default timeout
2854 wakeTimeoutCallback (void *param) {
2855 // We're using "param != NULL" as a cancellation mechanism
2856 if (param == NULL) {
2857 //LOGD("wakeTimeout: releasing wake lock");
2861 //LOGD("wakeTimeout: releasing wake lock CANCELLED");
2866 void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
2869 int unsolResponseIndex;
2871 int64_t timeReceived = 0;
2872 bool shouldScheduleTimeout = false;
2874 if (s_registerCalled == 0) {
2875 // Ignore RIL_onUnsolicitedResponse before RIL_register
2876 LOGW("RIL_onUnsolicitedResponse called before RIL_register");
2880 unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
2882 if ((unsolResponseIndex < 0)
2883 || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) {
2884 LOGE("unsupported unsolicited response code %d", unsolResponse);
2888 // Grab a wake lock if needed for this reponse,
2889 // as we exit we'll either release it immediately
2890 // or set a timer to release it later.
2891 switch (s_unsolResponses[unsolResponseIndex].wakeType) {
2893 grabPartialWakeLock();
2894 shouldScheduleTimeout = true;
2899 // No wake lock is grabed so don't set timeout
2900 shouldScheduleTimeout = false;
2904 // Mark the time this was received, doing this
2905 // after grabing the wakelock incase getting
2906 // the elapsedRealTime might cause us to goto
2908 if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
2909 timeReceived = elapsedRealtime();
2912 appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
2916 p.writeInt32 (RESPONSE_UNSOLICITED);
2917 p.writeInt32 (unsolResponse);
2919 ret = s_unsolResponses[unsolResponseIndex]
2920 .responseFunction(p, data, datalen);
2922 // Problem with the response. Don't continue;
2926 // some things get more payload
2927 switch(unsolResponse) {
2928 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
2929 p.writeInt32(s_callbacks.onStateRequest());
2930 appendPrintBuf("%s {%s}", printBuf,
2931 radioStateToString(s_callbacks.onStateRequest()));
2935 case RIL_UNSOL_NITZ_TIME_RECEIVED:
2936 // Store the time that this was received so the
2937 // handler of this message can account for
2938 // the time it takes to arrive and process. In
2939 // particular the system has been known to sleep
2940 // before this message can be processed.
2941 p.writeInt64(timeReceived);
2945 ret = sendResponse(p);
2946 if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
2948 // Unfortunately, NITZ time is not poll/update like everything
2949 // else in the system. So, if the upstream client isn't connected,
2950 // keep a copy of the last NITZ response (with receive time noted
2951 // above) around so we can deliver it when it is connected
2953 if (s_lastNITZTimeData != NULL) {
2954 free (s_lastNITZTimeData);
2955 s_lastNITZTimeData = NULL;
2958 s_lastNITZTimeData = malloc(p.dataSize());
2959 s_lastNITZTimeDataSize = p.dataSize();
2960 memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
2963 // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
2964 // FIXME The java code should handshake here to release wake lock
2966 if (shouldScheduleTimeout) {
2967 // Cancel the previous request
2968 if (s_last_wake_timeout_info != NULL) {
2969 s_last_wake_timeout_info->userParam = (void *)1;
2972 s_last_wake_timeout_info
2973 = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
2974 &TIMEVAL_WAKE_TIMEOUT);
2981 if (shouldScheduleTimeout) {
2986 /** FIXME generalize this if you track UserCAllbackInfo, clear it
2987 when the callback occurs
2989 static UserCallbackInfo *
2990 internalRequestTimedCallback (RIL_TimedCallback callback, void *param,
2991 const struct timeval *relativeTime)
2993 struct timeval myRelativeTime;
2994 UserCallbackInfo *p_info;
2996 p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
2998 p_info->p_callback = callback;
2999 p_info->userParam = param;
3001 if (relativeTime == NULL) {
3002 /* treat null parameter as a 0 relative time */
3003 memset (&myRelativeTime, 0, sizeof(myRelativeTime));
3005 /* FIXME I think event_add's tv param is really const anyway */
3006 memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));
3009 ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);
3011 ril_timer_add(&(p_info->event), &myRelativeTime);
3019 RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,
3020 const struct timeval *relativeTime) {
3021 internalRequestTimedCallback (callback, param, relativeTime);
3025 failCauseToString(RIL_Errno e) {
3027 case RIL_E_SUCCESS: return "E_SUCCESS";
3028 case RIL_E_RADIO_NOT_AVAILABLE: return "E_RAIDO_NOT_AVAILABLE";
3029 case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE";
3030 case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT";
3031 case RIL_E_SIM_PIN2: return "E_SIM_PIN2";
3032 case RIL_E_SIM_PUK2: return "E_SIM_PUK2";
3033 case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED";
3034 case RIL_E_CANCELLED: return "E_CANCELLED";
3035 case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL";
3036 case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
3037 case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY";
3038 case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT";
3039 case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME";
3040 #ifdef FEATURE_MULTIMODE_ANDROID
3041 case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
3042 case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
3044 default: return "<unknown error>";
3049 radioStateToString(RIL_RadioState s) {
3051 case RADIO_STATE_OFF: return "RADIO_OFF";
3052 case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE";
3053 case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY";
3054 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT";
3055 case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY";
3056 case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY";
3057 case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY";
3058 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT";
3059 case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY";
3060 case RADIO_STATE_NV_READY:return"RADIO_NV_READY";
3061 default: return "<unknown state>";
3066 callStateToString(RIL_CallState s) {
3068 case RIL_CALL_ACTIVE : return "ACTIVE";
3069 case RIL_CALL_HOLDING: return "HOLDING";
3070 case RIL_CALL_DIALING: return "DIALING";
3071 case RIL_CALL_ALERTING: return "ALERTING";
3072 case RIL_CALL_INCOMING: return "INCOMING";
3073 case RIL_CALL_WAITING: return "WAITING";
3074 default: return "<unknown state>";
3079 requestToString(int request) {
3081 cat libs/telephony/ril_commands.h \
3082 | egrep "^ *{RIL_" \
3083 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
3086 cat libs/telephony/ril_unsol_commands.h \
3087 | egrep "^ *{RIL_" \
3088 | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
3092 case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
3093 case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
3094 case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
3095 case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
3096 case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
3097 case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
3098 case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
3099 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
3100 case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
3101 case RIL_REQUEST_DIAL: return "DIAL";
3102 case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
3103 case RIL_REQUEST_HANGUP: return "HANGUP";
3104 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
3105 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
3106 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
3107 case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
3108 case RIL_REQUEST_UDUB: return "UDUB";
3109 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
3110 case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
3111 case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
3112 case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
3113 case RIL_REQUEST_OPERATOR: return "OPERATOR";
3114 case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
3115 case RIL_REQUEST_DTMF: return "DTMF";
3116 case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
3117 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
3118 case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
3119 case RIL_REQUEST_SIM_IO: return "SIM_IO";
3120 case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
3121 case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
3122 case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
3123 case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
3124 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
3125 case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
3126 case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
3127 case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
3128 case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
3129 case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
3130 case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
3131 case RIL_REQUEST_ANSWER: return "ANSWER";
3132 case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
3133 case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
3134 case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
3135 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
3136 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
3137 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
3138 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
3139 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
3140 case RIL_REQUEST_DTMF_START: return "DTMF_START";
3141 case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
3142 case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
3143 case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
3144 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
3145 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
3146 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
3147 case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
3148 case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
3149 case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
3150 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
3151 case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
3152 case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
3153 case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
3154 case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
3155 case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
3156 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
3157 case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
3158 case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
3159 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
3160 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
3161 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
3162 case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
3163 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
3164 case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
3165 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
3166 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
3167 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
3168 case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
3169 case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
3170 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
3171 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
3172 case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
3173 case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
3174 case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
3175 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
3176 case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
3177 case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
3178 case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
3179 case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
3180 case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
3181 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
3182 case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
3183 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
3184 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
3185 case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
3186 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
3187 case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
3188 case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
3189 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
3190 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
3191 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
3192 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
3193 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
3194 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
3195 case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
3196 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
3197 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
3198 case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
3199 case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
3200 case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
3201 case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
3202 case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
3203 case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
3204 case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
3205 case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
3206 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
3207 case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
3208 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
3209 case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
3210 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
3211 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
3212 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
3213 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
3214 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
3215 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
3216 case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
3217 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
3218 case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
3219 case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
3220 case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
3221 case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
3222 case RIL_UNSOL_CDMA_SUBSCRIPTION_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_CHANGED";
3223 case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
3224 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
3225 case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
3226 default: return "<unknown request>";
3230 } /* namespace android */