blob: 41e2fd244fd5559072eb4b70d399bdbf9092ba10 [file] [log] [blame]
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001/* //device/libs/telephony/ril.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
Wink Saville7f856802009-06-09 10:23:37 -07005** 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
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08008**
Wink Saville7f856802009-06-09 10:23:37 -07009** http://www.apache.org/licenses/LICENSE-2.0
The Android Open Source Project00f06fc2009-03-03 19:32:15 -080010**
Wink Saville7f856802009-06-09 10:23:37 -070011** 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
The Android Open Source Project00f06fc2009-03-03 19:32:15 -080015** limitations under the License.
16*/
17
18#define LOG_TAG "RILC"
19
20#include <hardware_legacy/power.h>
21
22#include <telephony/ril.h>
Wink Savillef4c4d362009-04-02 01:37:03 -070023#include <telephony/ril_cdma_sms.h>
The Android Open Source Project00f06fc2009-03-03 19:32:15 -080024#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>
29#include <pthread.h>
Mathias Agopian8a3c48c2009-05-19 19:11:50 -070030#include <binder/Parcel.h>
The Android Open Source Project00f06fc2009-03-03 19:32:15 -080031#include <cutils/jstring.h>
32
33#include <sys/types.h>
34#include <pwd.h>
35
36#include <stdio.h>
37#include <stdlib.h>
38#include <stdarg.h>
39#include <string.h>
40#include <unistd.h>
41#include <fcntl.h>
42#include <time.h>
43#include <errno.h>
44#include <assert.h>
45#include <ctype.h>
46#include <alloca.h>
47#include <sys/un.h>
48#include <assert.h>
49#include <netinet/in.h>
50#include <cutils/properties.h>
51
52#include <ril_event.h>
53
54namespace android {
55
56#define PHONE_PROCESS "radio"
57
58#define SOCKET_NAME_RIL "rild"
59#define SOCKET_NAME_RIL_DEBUG "rild-debug"
60
61#define ANDROID_WAKE_LOCK_NAME "radio-interface"
62
63
64#define PROPERTY_RIL_IMPL "gsm.version.ril-impl"
65
66// match with constant in RIL.java
67#define MAX_COMMAND_BYTES (8 * 1024)
68
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
73
74#define NUM_ELEMS(a) (sizeof (a) / sizeof (a)[0])
75
Wink Savillef4c4d362009-04-02 01:37:03 -070076#define MIN(a,b) ((a)<(b) ? (a) : (b))
77
The Android Open Source Project00f06fc2009-03-03 19:32:15 -080078/* Constants for response types */
79#define RESPONSE_SOLICITED 0
80#define RESPONSE_UNSOLICITED 1
81
82/* Negative values for private RIL errno's */
83#define RIL_ERRNO_INVALID_RESPONSE -1
84
85// request, response, and unsolicited msg print macro
86#define PRINTBUF_SIZE 8096
87
88// Enable RILC log
89#define RILC_LOG 0
90
91#if RILC_LOG
92 #define startRequest sprintf(printBuf, "(")
93 #define closeRequest sprintf(printBuf, "%s)", printBuf)
94 #define printRequest(token, req) \
Wink Saville8eb2a122012-11-19 16:05:13 -080095 RLOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
The Android Open Source Project00f06fc2009-03-03 19:32:15 -080096
97 #define startResponse sprintf(printBuf, "%s {", printBuf)
98 #define closeResponse sprintf(printBuf, "%s}", printBuf)
Wink Saville8eb2a122012-11-19 16:05:13 -080099 #define printResponse RLOGD("%s", printBuf)
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800100
101 #define clearPrintBuf printBuf[0] = 0
102 #define removeLastChar printBuf[strlen(printBuf)-1] = 0
103 #define appendPrintBuf(x...) sprintf(printBuf, x)
104#else
105 #define startRequest
106 #define closeRequest
107 #define printRequest(token, req)
108 #define startResponse
109 #define closeResponse
110 #define printResponse
111 #define clearPrintBuf
112 #define removeLastChar
113 #define appendPrintBuf(x...)
114#endif
115
116enum WakeType {DONT_WAKE, WAKE_PARTIAL};
117
118typedef struct {
119 int requestNumber;
120 void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);
121 int(*responseFunction) (Parcel &p, void *response, size_t responselen);
122} CommandInfo;
123
124typedef struct {
125 int requestNumber;
126 int (*responseFunction) (Parcel &p, void *response, size_t responselen);
127 WakeType wakeType;
128} UnsolResponseInfo;
129
130typedef struct RequestInfo {
Wink Saville7f856802009-06-09 10:23:37 -0700131 int32_t token; //this is not RIL_Token
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800132 CommandInfo *pCI;
133 struct RequestInfo *p_next;
134 char cancelled;
135 char local; // responses to local commands do not go back to command process
136} RequestInfo;
137
Wink Saville3d54e742009-05-18 18:00:44 -0700138typedef struct UserCallbackInfo {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800139 RIL_TimedCallback p_callback;
140 void *userParam;
141 struct ril_event event;
142 struct UserCallbackInfo *p_next;
143} UserCallbackInfo;
144
Dianne Hackborn0d9f0c02010-06-25 16:50:46 -0700145
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800146/*******************************************************************/
147
148RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
149static int s_registerCalled = 0;
150
151static pthread_t s_tid_dispatch;
152static pthread_t s_tid_reader;
153static int s_started = 0;
154
155static int s_fdListen = -1;
156static int s_fdCommand = -1;
157static int s_fdDebug = -1;
158
159static int s_fdWakeupRead;
160static int s_fdWakeupWrite;
161
162static struct ril_event s_commands_event;
163static struct ril_event s_wakeupfd_event;
164static struct ril_event s_listen_event;
165static struct ril_event s_wake_timeout_event;
166static struct ril_event s_debug_event;
167
168
169static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0};
170
171static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
172static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
173static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
174static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
175
176static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
177static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
178
179static RequestInfo *s_pendingRequests = NULL;
180
181static RequestInfo *s_toDispatchHead = NULL;
182static RequestInfo *s_toDispatchTail = NULL;
183
184static UserCallbackInfo *s_last_wake_timeout_info = NULL;
185
186static void *s_lastNITZTimeData = NULL;
187static size_t s_lastNITZTimeDataSize;
188
189#if RILC_LOG
190 static char printBuf[PRINTBUF_SIZE];
191#endif
192
193/*******************************************************************/
194
195static void dispatchVoid (Parcel& p, RequestInfo *pRI);
196static void dispatchString (Parcel& p, RequestInfo *pRI);
197static void dispatchStrings (Parcel& p, RequestInfo *pRI);
198static void dispatchInts (Parcel& p, RequestInfo *pRI);
199static void dispatchDial (Parcel& p, RequestInfo *pRI);
200static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI);
201static void dispatchCallForward(Parcel& p, RequestInfo *pRI);
202static void dispatchRaw(Parcel& p, RequestInfo *pRI);
203static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI);
Lorenzo Colitti4f81dcf2010-09-01 19:38:57 -0700204static void dispatchDataCall (Parcel& p, RequestInfo *pRI);
Naveen Kalla2bc78d62011-12-07 16:22:53 -0800205static void dispatchVoiceRadioTech (Parcel& p, RequestInfo *pRI);
206static void dispatchCdmaSubscriptionSource (Parcel& p, RequestInfo *pRI);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800207
Wink Savillef4c4d362009-04-02 01:37:03 -0700208static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI);
209static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI);
Wink Savillea592eeb2009-05-22 13:26:36 -0700210static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI);
Wink Savillef4c4d362009-04-02 01:37:03 -0700211static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI);
212static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800213static int responseInts(Parcel &p, void *response, size_t responselen);
214static int responseStrings(Parcel &p, void *response, size_t responselen);
215static int responseString(Parcel &p, void *response, size_t responselen);
216static int responseVoid(Parcel &p, void *response, size_t responselen);
217static int responseCallList(Parcel &p, void *response, size_t responselen);
218static int responseSMS(Parcel &p, void *response, size_t responselen);
219static int responseSIM_IO(Parcel &p, void *response, size_t responselen);
220static int responseCallForwards(Parcel &p, void *response, size_t responselen);
Wink Savillef4c4d362009-04-02 01:37:03 -0700221static int responseDataCallList(Parcel &p, void *response, size_t responselen);
Wink Saville43808972011-01-13 17:39:51 -0800222static int responseSetupDataCall(Parcel &p, void *response, size_t responselen);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800223static int responseRaw(Parcel &p, void *response, size_t responselen);
224static int responseSsn(Parcel &p, void *response, size_t responselen);
Wink Savillef4c4d362009-04-02 01:37:03 -0700225static int responseSimStatus(Parcel &p, void *response, size_t responselen);
Wink Savillea592eeb2009-05-22 13:26:36 -0700226static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen);
227static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen);
Wink Savillef4c4d362009-04-02 01:37:03 -0700228static int responseCdmaSms(Parcel &p, void *response, size_t responselen);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800229static int responseCellList(Parcel &p, void *response, size_t responselen);
Wink Saville3d54e742009-05-18 18:00:44 -0700230static int responseCdmaInformationRecords(Parcel &p,void *response, size_t responselen);
231static int responseRilSignalStrength(Parcel &p,void *response, size_t responselen);
232static int responseCallRing(Parcel &p, void *response, size_t responselen);
233static int responseCdmaSignalInfoRecord(Parcel &p,void *response, size_t responselen);
234static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen);
Alex Yakavenka45e740e2012-01-31 11:48:27 -0800235static int responseSimRefresh(Parcel &p, void *response, size_t responselen);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800236
Naveen Kalla2bc78d62011-12-07 16:22:53 -0800237static int decodeVoiceRadioTechnology (RIL_RadioState radioState);
238static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
239static RIL_RadioState processRadioState(RIL_RadioState newRadioState);
240
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800241extern "C" const char * requestToString(int request);
242extern "C" const char * failCauseToString(RIL_Errno);
243extern "C" const char * callStateToString(RIL_CallState);
244extern "C" const char * radioStateToString(RIL_RadioState);
245
246#ifdef RIL_SHLIB
Wink Saville7f856802009-06-09 10:23:37 -0700247extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800248 size_t datalen);
249#endif
250
Wink Saville7f856802009-06-09 10:23:37 -0700251static UserCallbackInfo * internalRequestTimedCallback
Dianne Hackborn0d9f0c02010-06-25 16:50:46 -0700252 (RIL_TimedCallback callback, void *param,
253 const struct timeval *relativeTime);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800254
255/** Index == requestNumber */
256static CommandInfo s_commands[] = {
257#include "ril_commands.h"
258};
259
260static UnsolResponseInfo s_unsolResponses[] = {
261#include "ril_unsol_commands.h"
262};
263
Naveen Kalla2bc78d62011-12-07 16:22:53 -0800264/* For older RILs that do not support new commands RIL_REQUEST_VOICE_RADIO_TECH and
265 RIL_UNSOL_VOICE_RADIO_TECH_CHANGED messages, decode the voice radio tech from
266 radio state message and store it. Every time there is a change in Radio State
267 check to see if voice radio tech changes and notify telephony
268 */
269int voiceRadioTech = -1;
270
271/* For older RILs that do not support new commands RIL_REQUEST_GET_CDMA_SUBSCRIPTION_SOURCE
272 and RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED messages, decode the subscription
273 source from radio state and store it. Every time there is a change in Radio State
274 check to see if subscription source changed and notify telephony
275 */
276int cdmaSubscriptionSource = -1;
277
278/* For older RILs that do not send RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, decode the
279 SIM/RUIM state from radio state and store it. Every time there is a change in Radio State,
280 check to see if SIM/RUIM status changed and notify telephony
281 */
282int simRuimStatus = -1;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800283
284static char *
Wink Savillef4c4d362009-04-02 01:37:03 -0700285strdupReadString(Parcel &p) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800286 size_t stringlen;
287 const char16_t *s16;
Wink Saville7f856802009-06-09 10:23:37 -0700288
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800289 s16 = p.readString16Inplace(&stringlen);
Wink Saville7f856802009-06-09 10:23:37 -0700290
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800291 return strndup16to8(s16, stringlen);
292}
293
Wink Savillef4c4d362009-04-02 01:37:03 -0700294static void writeStringToParcel(Parcel &p, const char *s) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800295 char16_t *s16;
296 size_t s16_len;
297 s16 = strdup8to16(s, &s16_len);
298 p.writeString16(s16, s16_len);
299 free(s16);
300}
301
302
303static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700304memsetString (char *s) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800305 if (s != NULL) {
306 memset (s, 0, strlen(s));
307 }
308}
309
310void nullParcelReleaseFunction (const uint8_t* data, size_t dataSize,
311 const size_t* objects, size_t objectsSize,
Wink Savillef4c4d362009-04-02 01:37:03 -0700312 void* cookie) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800313 // do nothing -- the data reference lives longer than the Parcel object
314}
315
Wink Saville7f856802009-06-09 10:23:37 -0700316/**
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800317 * To be called from dispatch thread
318 * Issue a single local request, ensuring that the response
Wink Saville7f856802009-06-09 10:23:37 -0700319 * is not sent back up to the command process
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800320 */
321static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700322issueLocalRequest(int request, void *data, int len) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800323 RequestInfo *pRI;
324 int ret;
325
326 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
327
328 pRI->local = 1;
329 pRI->token = 0xffffffff; // token is not used in this context
330 pRI->pCI = &(s_commands[request]);
331
332 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
333 assert (ret == 0);
334
335 pRI->p_next = s_pendingRequests;
336 s_pendingRequests = pRI;
337
338 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
339 assert (ret == 0);
340
Wink Saville8eb2a122012-11-19 16:05:13 -0800341 RLOGD("C[locl]> %s", requestToString(request));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800342
343 s_callbacks.onRequest(request, data, len, pRI);
344}
345
346
347
348static int
Wink Savillef4c4d362009-04-02 01:37:03 -0700349processCommandBuffer(void *buffer, size_t buflen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800350 Parcel p;
351 status_t status;
352 int32_t request;
353 int32_t token;
354 RequestInfo *pRI;
355 int ret;
356
357 p.setData((uint8_t *) buffer, buflen);
358
359 // status checked at end
360 status = p.readInt32(&request);
361 status = p.readInt32 (&token);
362
363 if (status != NO_ERROR) {
Wink Saville8eb2a122012-11-19 16:05:13 -0800364 RLOGE("invalid request block");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800365 return 0;
366 }
367
368 if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
Wink Saville8eb2a122012-11-19 16:05:13 -0800369 RLOGE("unsupported request code %d token %d", request, token);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800370 // FIXME this should perhaps return a response
371 return 0;
372 }
373
374
375 pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
376
377 pRI->token = token;
378 pRI->pCI = &(s_commands[request]);
379
380 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
381 assert (ret == 0);
382
383 pRI->p_next = s_pendingRequests;
384 s_pendingRequests = pRI;
385
386 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
387 assert (ret == 0);
388
389/* sLastDispatchedToken = token; */
390
Wink Saville7f856802009-06-09 10:23:37 -0700391 pRI->pCI->dispatchFunction(p, pRI);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800392
393 return 0;
394}
395
396static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700397invalidCommandBlock (RequestInfo *pRI) {
Wink Saville8eb2a122012-11-19 16:05:13 -0800398 RLOGE("invalid command block for token %d request %s",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800399 pRI->token, requestToString(pRI->pCI->requestNumber));
400}
401
402/** Callee expects NULL */
Wink Saville7f856802009-06-09 10:23:37 -0700403static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700404dispatchVoid (Parcel& p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800405 clearPrintBuf;
406 printRequest(pRI->token, pRI->pCI->requestNumber);
407 s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);
408}
409
410/** Callee expects const char * */
411static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700412dispatchString (Parcel& p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800413 status_t status;
414 size_t datalen;
415 size_t stringlen;
416 char *string8 = NULL;
417
418 string8 = strdupReadString(p);
419
420 startRequest;
421 appendPrintBuf("%s%s", printBuf, string8);
422 closeRequest;
423 printRequest(pRI->token, pRI->pCI->requestNumber);
424
425 s_callbacks.onRequest(pRI->pCI->requestNumber, string8,
426 sizeof(char *), pRI);
427
428#ifdef MEMSET_FREED
429 memsetString(string8);
430#endif
431
432 free(string8);
433 return;
434invalid:
435 invalidCommandBlock(pRI);
436 return;
437}
438
439/** Callee expects const char ** */
440static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700441dispatchStrings (Parcel &p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800442 int32_t countStrings;
443 status_t status;
444 size_t datalen;
445 char **pStrings;
446
447 status = p.readInt32 (&countStrings);
448
449 if (status != NO_ERROR) {
450 goto invalid;
451 }
452
453 startRequest;
454 if (countStrings == 0) {
455 // just some non-null pointer
456 pStrings = (char **)alloca(sizeof(char *));
457 datalen = 0;
458 } else if (((int)countStrings) == -1) {
459 pStrings = NULL;
460 datalen = 0;
461 } else {
462 datalen = sizeof(char *) * countStrings;
Wink Saville7f856802009-06-09 10:23:37 -0700463
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800464 pStrings = (char **)alloca(datalen);
465
466 for (int i = 0 ; i < countStrings ; i++) {
467 pStrings[i] = strdupReadString(p);
468 appendPrintBuf("%s%s,", printBuf, pStrings[i]);
469 }
470 }
471 removeLastChar;
472 closeRequest;
473 printRequest(pRI->token, pRI->pCI->requestNumber);
474
475 s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI);
476
477 if (pStrings != NULL) {
478 for (int i = 0 ; i < countStrings ; i++) {
479#ifdef MEMSET_FREED
480 memsetString (pStrings[i]);
481#endif
482 free(pStrings[i]);
483 }
484
485#ifdef MEMSET_FREED
486 memset(pStrings, 0, datalen);
487#endif
488 }
Wink Saville7f856802009-06-09 10:23:37 -0700489
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800490 return;
491invalid:
492 invalidCommandBlock(pRI);
493 return;
494}
495
496/** Callee expects const int * */
497static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700498dispatchInts (Parcel &p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800499 int32_t count;
500 status_t status;
501 size_t datalen;
502 int *pInts;
503
504 status = p.readInt32 (&count);
505
506 if (status != NO_ERROR || count == 0) {
507 goto invalid;
508 }
509
510 datalen = sizeof(int) * count;
511 pInts = (int *)alloca(datalen);
512
513 startRequest;
514 for (int i = 0 ; i < count ; i++) {
515 int32_t t;
516
517 status = p.readInt32(&t);
518 pInts[i] = (int)t;
519 appendPrintBuf("%s%d,", printBuf, t);
520
521 if (status != NO_ERROR) {
522 goto invalid;
523 }
524 }
525 removeLastChar;
526 closeRequest;
527 printRequest(pRI->token, pRI->pCI->requestNumber);
528
Wink Saville7f856802009-06-09 10:23:37 -0700529 s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts),
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800530 datalen, pRI);
531
532#ifdef MEMSET_FREED
533 memset(pInts, 0, datalen);
534#endif
535
536 return;
537invalid:
538 invalidCommandBlock(pRI);
539 return;
540}
541
542
Wink Saville7f856802009-06-09 10:23:37 -0700543/**
544 * Callee expects const RIL_SMS_WriteArgs *
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800545 * Payload is:
546 * int32_t status
547 * String pdu
548 */
549static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700550dispatchSmsWrite (Parcel &p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800551 RIL_SMS_WriteArgs args;
552 int32_t t;
553 status_t status;
554
555 memset (&args, 0, sizeof(args));
556
557 status = p.readInt32(&t);
558 args.status = (int)t;
559
560 args.pdu = strdupReadString(p);
561
562 if (status != NO_ERROR || args.pdu == NULL) {
563 goto invalid;
564 }
565
566 args.smsc = strdupReadString(p);
567
568 startRequest;
569 appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status,
570 (char*)args.pdu, (char*)args.smsc);
571 closeRequest;
572 printRequest(pRI->token, pRI->pCI->requestNumber);
Wink Saville7f856802009-06-09 10:23:37 -0700573
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800574 s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI);
575
576#ifdef MEMSET_FREED
577 memsetString (args.pdu);
578#endif
579
580 free (args.pdu);
Wink Saville7f856802009-06-09 10:23:37 -0700581
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800582#ifdef MEMSET_FREED
583 memset(&args, 0, sizeof(args));
584#endif
585
586 return;
587invalid:
588 invalidCommandBlock(pRI);
589 return;
590}
591
Wink Saville7f856802009-06-09 10:23:37 -0700592/**
593 * Callee expects const RIL_Dial *
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800594 * Payload is:
595 * String address
596 * int32_t clir
597 */
598static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700599dispatchDial (Parcel &p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800600 RIL_Dial dial;
Wink Saville74fa3882009-12-22 15:35:41 -0800601 RIL_UUS_Info uusInfo;
Wink Saville7bce0822010-01-08 15:20:12 -0800602 int32_t sizeOfDial;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800603 int32_t t;
Wink Saville74fa3882009-12-22 15:35:41 -0800604 int32_t uusPresent;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800605 status_t status;
606
607 memset (&dial, 0, sizeof(dial));
608
609 dial.address = strdupReadString(p);
610
611 status = p.readInt32(&t);
612 dial.clir = (int)t;
613
614 if (status != NO_ERROR || dial.address == NULL) {
615 goto invalid;
616 }
617
Wink Saville3a4840b2010-04-07 13:29:58 -0700618 if (s_callbacks.version < 3) { // Remove when partners upgrade to version 3
Wink Saville74fa3882009-12-22 15:35:41 -0800619 uusPresent = 0;
Wink Saville7bce0822010-01-08 15:20:12 -0800620 sizeOfDial = sizeof(dial) - sizeof(RIL_UUS_Info *);
Wink Saville74fa3882009-12-22 15:35:41 -0800621 } else {
622 status = p.readInt32(&uusPresent);
623
624 if (status != NO_ERROR) {
625 goto invalid;
626 }
627
628 if (uusPresent == 0) {
629 dial.uusInfo = NULL;
630 } else {
631 int32_t len;
632
633 memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
634
635 status = p.readInt32(&t);
636 uusInfo.uusType = (RIL_UUS_Type) t;
637
638 status = p.readInt32(&t);
639 uusInfo.uusDcs = (RIL_UUS_DCS) t;
640
641 status = p.readInt32(&len);
642 if (status != NO_ERROR) {
643 goto invalid;
644 }
645
646 // The java code writes -1 for null arrays
647 if (((int) len) == -1) {
648 uusInfo.uusData = NULL;
649 len = 0;
650 } else {
651 uusInfo.uusData = (char*) p.readInplace(len);
652 }
653
654 uusInfo.uusLength = len;
655 dial.uusInfo = &uusInfo;
656 }
Wink Saville7bce0822010-01-08 15:20:12 -0800657 sizeOfDial = sizeof(dial);
Wink Saville74fa3882009-12-22 15:35:41 -0800658 }
659
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800660 startRequest;
661 appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir);
Wink Saville74fa3882009-12-22 15:35:41 -0800662 if (uusPresent) {
663 appendPrintBuf("%s,uusType=%d,uusDcs=%d,uusLen=%d", printBuf,
664 dial.uusInfo->uusType, dial.uusInfo->uusDcs,
665 dial.uusInfo->uusLength);
666 }
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800667 closeRequest;
668 printRequest(pRI->token, pRI->pCI->requestNumber);
669
Wink Saville7bce0822010-01-08 15:20:12 -0800670 s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800671
672#ifdef MEMSET_FREED
673 memsetString (dial.address);
674#endif
675
676 free (dial.address);
Wink Saville7f856802009-06-09 10:23:37 -0700677
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800678#ifdef MEMSET_FREED
Wink Saville74fa3882009-12-22 15:35:41 -0800679 memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800680 memset(&dial, 0, sizeof(dial));
681#endif
682
683 return;
684invalid:
685 invalidCommandBlock(pRI);
686 return;
687}
688
Wink Saville7f856802009-06-09 10:23:37 -0700689/**
690 * Callee expects const RIL_SIM_IO *
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800691 * Payload is:
692 * int32_t command
693 * int32_t fileid
694 * String path
695 * int32_t p1, p2, p3
Wink Saville7f856802009-06-09 10:23:37 -0700696 * String data
697 * String pin2
Wink Savillec0114b32011-02-18 10:14:07 -0800698 * String aidPtr
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800699 */
700static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700701dispatchSIM_IO (Parcel &p, RequestInfo *pRI) {
Wink Savillec0114b32011-02-18 10:14:07 -0800702 union RIL_SIM_IO {
703 RIL_SIM_IO_v6 v6;
704 RIL_SIM_IO_v5 v5;
705 } simIO;
706
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800707 int32_t t;
Wink Savillec0114b32011-02-18 10:14:07 -0800708 int size;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800709 status_t status;
710
711 memset (&simIO, 0, sizeof(simIO));
712
Wink Saville7f856802009-06-09 10:23:37 -0700713 // note we only check status at the end
714
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800715 status = p.readInt32(&t);
Wink Savillec0114b32011-02-18 10:14:07 -0800716 simIO.v6.command = (int)t;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800717
718 status = p.readInt32(&t);
Wink Savillec0114b32011-02-18 10:14:07 -0800719 simIO.v6.fileid = (int)t;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800720
Wink Savillec0114b32011-02-18 10:14:07 -0800721 simIO.v6.path = strdupReadString(p);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800722
723 status = p.readInt32(&t);
Wink Savillec0114b32011-02-18 10:14:07 -0800724 simIO.v6.p1 = (int)t;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800725
726 status = p.readInt32(&t);
Wink Savillec0114b32011-02-18 10:14:07 -0800727 simIO.v6.p2 = (int)t;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800728
729 status = p.readInt32(&t);
Wink Savillec0114b32011-02-18 10:14:07 -0800730 simIO.v6.p3 = (int)t;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800731
Wink Savillec0114b32011-02-18 10:14:07 -0800732 simIO.v6.data = strdupReadString(p);
733 simIO.v6.pin2 = strdupReadString(p);
734 simIO.v6.aidPtr = strdupReadString(p);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800735
736 startRequest;
Wink Savillec0114b32011-02-18 10:14:07 -0800737 appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s,aid=%s", printBuf,
738 simIO.v6.command, simIO.v6.fileid, (char*)simIO.v6.path,
739 simIO.v6.p1, simIO.v6.p2, simIO.v6.p3,
740 (char*)simIO.v6.data, (char*)simIO.v6.pin2, simIO.v6.aidPtr);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800741 closeRequest;
742 printRequest(pRI->token, pRI->pCI->requestNumber);
Wink Saville7f856802009-06-09 10:23:37 -0700743
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800744 if (status != NO_ERROR) {
745 goto invalid;
746 }
747
Wink Savillec0114b32011-02-18 10:14:07 -0800748 size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6);
749 s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, size, pRI);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800750
751#ifdef MEMSET_FREED
Wink Savillec0114b32011-02-18 10:14:07 -0800752 memsetString (simIO.v6.path);
753 memsetString (simIO.v6.data);
754 memsetString (simIO.v6.pin2);
755 memsetString (simIO.v6.aidPtr);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800756#endif
757
Wink Savillec0114b32011-02-18 10:14:07 -0800758 free (simIO.v6.path);
759 free (simIO.v6.data);
760 free (simIO.v6.pin2);
761 free (simIO.v6.aidPtr);
Wink Saville7f856802009-06-09 10:23:37 -0700762
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800763#ifdef MEMSET_FREED
764 memset(&simIO, 0, sizeof(simIO));
765#endif
766
767 return;
768invalid:
769 invalidCommandBlock(pRI);
770 return;
771}
772
773/**
774 * Callee expects const RIL_CallForwardInfo *
775 * Payload is:
776 * int32_t status/action
777 * int32_t reason
778 * int32_t serviceCode
779 * int32_t toa
780 * String number (0 length -> null)
781 * int32_t timeSeconds
782 */
Wink Saville7f856802009-06-09 10:23:37 -0700783static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700784dispatchCallForward(Parcel &p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800785 RIL_CallForwardInfo cff;
786 int32_t t;
787 status_t status;
788
789 memset (&cff, 0, sizeof(cff));
790
Wink Saville7f856802009-06-09 10:23:37 -0700791 // note we only check status at the end
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800792
793 status = p.readInt32(&t);
794 cff.status = (int)t;
Wink Saville7f856802009-06-09 10:23:37 -0700795
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800796 status = p.readInt32(&t);
797 cff.reason = (int)t;
798
799 status = p.readInt32(&t);
800 cff.serviceClass = (int)t;
801
802 status = p.readInt32(&t);
803 cff.toa = (int)t;
804
805 cff.number = strdupReadString(p);
806
807 status = p.readInt32(&t);
808 cff.timeSeconds = (int)t;
809
810 if (status != NO_ERROR) {
811 goto invalid;
812 }
813
814 // special case: number 0-length fields is null
815
816 if (cff.number != NULL && strlen (cff.number) == 0) {
817 cff.number = NULL;
818 }
819
820 startRequest;
821 appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf,
822 cff.status, cff.reason, cff.serviceClass, cff.toa,
823 (char*)cff.number, cff.timeSeconds);
824 closeRequest;
825 printRequest(pRI->token, pRI->pCI->requestNumber);
826
827 s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI);
828
829#ifdef MEMSET_FREED
830 memsetString(cff.number);
831#endif
832
833 free (cff.number);
834
835#ifdef MEMSET_FREED
836 memset(&cff, 0, sizeof(cff));
837#endif
838
839 return;
840invalid:
841 invalidCommandBlock(pRI);
842 return;
843}
844
845
Wink Saville7f856802009-06-09 10:23:37 -0700846static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700847dispatchRaw(Parcel &p, RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800848 int32_t len;
849 status_t status;
850 const void *data;
851
852 status = p.readInt32(&len);
853
854 if (status != NO_ERROR) {
855 goto invalid;
856 }
857
858 // The java code writes -1 for null arrays
859 if (((int)len) == -1) {
860 data = NULL;
861 len = 0;
Wink Saville7f856802009-06-09 10:23:37 -0700862 }
The Android Open Source Project00f06fc2009-03-03 19:32:15 -0800863
864 data = p.readInplace(len);
865
866 startRequest;
867 appendPrintBuf("%sraw_size=%d", printBuf, len);
868 closeRequest;
869 printRequest(pRI->token, pRI->pCI->requestNumber);
870
871 s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI);
872
873 return;
874invalid:
875 invalidCommandBlock(pRI);
876 return;
877}
878
Wink Saville7f856802009-06-09 10:23:37 -0700879static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700880dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
881 RIL_CDMA_SMS_Message rcsm;
882 int32_t t;
883 uint8_t ut;
884 status_t status;
885 int32_t digitCount;
886 int digitLimit;
Wink Saville7f856802009-06-09 10:23:37 -0700887
Wink Savillef4c4d362009-04-02 01:37:03 -0700888 memset(&rcsm, 0, sizeof(rcsm));
889
890 status = p.readInt32(&t);
891 rcsm.uTeleserviceID = (int) t;
892
893 status = p.read(&ut,sizeof(ut));
894 rcsm.bIsServicePresent = (uint8_t) ut;
895
896 status = p.readInt32(&t);
897 rcsm.uServicecategory = (int) t;
898
899 status = p.readInt32(&t);
900 rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
901
902 status = p.readInt32(&t);
903 rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
904
905 status = p.readInt32(&t);
906 rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
907
908 status = p.readInt32(&t);
909 rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
910
911 status = p.read(&ut,sizeof(ut));
912 rcsm.sAddress.number_of_digits= (uint8_t) ut;
913
914 digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
915 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
916 status = p.read(&ut,sizeof(ut));
917 rcsm.sAddress.digits[digitCount] = (uint8_t) ut;
918 }
919
Wink Saville7f856802009-06-09 10:23:37 -0700920 status = p.readInt32(&t);
Wink Savillef4c4d362009-04-02 01:37:03 -0700921 rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
922
Wink Saville7f856802009-06-09 10:23:37 -0700923 status = p.read(&ut,sizeof(ut));
Wink Savillef4c4d362009-04-02 01:37:03 -0700924 rcsm.sSubAddress.odd = (uint8_t) ut;
925
926 status = p.read(&ut,sizeof(ut));
927 rcsm.sSubAddress.number_of_digits = (uint8_t) ut;
928
929 digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
Wink Saville7f856802009-06-09 10:23:37 -0700930 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
931 status = p.read(&ut,sizeof(ut));
Wink Savillef4c4d362009-04-02 01:37:03 -0700932 rcsm.sSubAddress.digits[digitCount] = (uint8_t) ut;
933 }
934
Wink Saville7f856802009-06-09 10:23:37 -0700935 status = p.readInt32(&t);
Wink Savillef4c4d362009-04-02 01:37:03 -0700936 rcsm.uBearerDataLen = (int) t;
937
938 digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
Wink Saville7f856802009-06-09 10:23:37 -0700939 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
940 status = p.read(&ut, sizeof(ut));
Wink Savillef4c4d362009-04-02 01:37:03 -0700941 rcsm.aBearerData[digitCount] = (uint8_t) ut;
942 }
943
944 if (status != NO_ERROR) {
945 goto invalid;
946 }
947
948 startRequest;
949 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
Wink Saville1b5fd232009-04-22 14:50:00 -0700950 sAddress.digit_mode=%d, sAddress.Number_mode=%d, sAddress.number_type=%d, ",
Wink Savillef4c4d362009-04-02 01:37:03 -0700951 printBuf, rcsm.uTeleserviceID,rcsm.bIsServicePresent,rcsm.uServicecategory,
Wink Saville1b5fd232009-04-22 14:50:00 -0700952 rcsm.sAddress.digit_mode, rcsm.sAddress.number_mode,rcsm.sAddress.number_type);
Wink Savillef4c4d362009-04-02 01:37:03 -0700953 closeRequest;
Wink Saville7f856802009-06-09 10:23:37 -0700954
Wink Savillef4c4d362009-04-02 01:37:03 -0700955 printRequest(pRI->token, pRI->pCI->requestNumber);
956
957 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI);
958
959#ifdef MEMSET_FREED
960 memset(&rcsm, 0, sizeof(rcsm));
961#endif
962
963 return;
964
965invalid:
966 invalidCommandBlock(pRI);
967 return;
968}
969
Wink Saville7f856802009-06-09 10:23:37 -0700970static void
Wink Savillef4c4d362009-04-02 01:37:03 -0700971dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) {
972 RIL_CDMA_SMS_Ack rcsa;
973 int32_t t;
974 status_t status;
975 int32_t digitCount;
976
977 memset(&rcsa, 0, sizeof(rcsa));
978
979 status = p.readInt32(&t);
980 rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t;
981
982 status = p.readInt32(&t);
983 rcsa.uSMSCauseCode = (int) t;
984
985 if (status != NO_ERROR) {
986 goto invalid;
987 }
988
989 startRequest;
Wink Saville1b5fd232009-04-22 14:50:00 -0700990 appendPrintBuf("%suErrorClass=%d, uTLStatus=%d, ",
991 printBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode);
Wink Savillef4c4d362009-04-02 01:37:03 -0700992 closeRequest;
993
994 printRequest(pRI->token, pRI->pCI->requestNumber);
995
996 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI);
997
998#ifdef MEMSET_FREED
999 memset(&rcsa, 0, sizeof(rcsa));
1000#endif
1001
1002 return;
1003
1004invalid:
1005 invalidCommandBlock(pRI);
1006 return;
1007}
1008
Wink Savillea592eeb2009-05-22 13:26:36 -07001009static void
1010dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1011 int32_t t;
Wink Savillef4c4d362009-04-02 01:37:03 -07001012 status_t status;
Wink Savillea592eeb2009-05-22 13:26:36 -07001013 int32_t num;
Wink Savillef4c4d362009-04-02 01:37:03 -07001014
Wink Savillea592eeb2009-05-22 13:26:36 -07001015 status = p.readInt32(&num);
Wink Savillef4c4d362009-04-02 01:37:03 -07001016 if (status != NO_ERROR) {
1017 goto invalid;
1018 }
1019
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001020 {
1021 RIL_GSM_BroadcastSmsConfigInfo gsmBci[num];
1022 RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num];
Wink Savillea592eeb2009-05-22 13:26:36 -07001023
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001024 startRequest;
1025 for (int i = 0 ; i < num ; i++ ) {
1026 gsmBciPtrs[i] = &gsmBci[i];
Wink Savillef4c4d362009-04-02 01:37:03 -07001027
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001028 status = p.readInt32(&t);
1029 gsmBci[i].fromServiceId = (int) t;
Wink Savillef4c4d362009-04-02 01:37:03 -07001030
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001031 status = p.readInt32(&t);
1032 gsmBci[i].toServiceId = (int) t;
Wink Savillef4c4d362009-04-02 01:37:03 -07001033
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001034 status = p.readInt32(&t);
1035 gsmBci[i].fromCodeScheme = (int) t;
Wink Savillef4c4d362009-04-02 01:37:03 -07001036
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001037 status = p.readInt32(&t);
1038 gsmBci[i].toCodeScheme = (int) t;
Wink Savillef4c4d362009-04-02 01:37:03 -07001039
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001040 status = p.readInt32(&t);
1041 gsmBci[i].selected = (uint8_t) t;
Wink Savillef4c4d362009-04-02 01:37:03 -07001042
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001043 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId =%d, \
1044 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", printBuf, i,
1045 gsmBci[i].fromServiceId, gsmBci[i].toServiceId,
1046 gsmBci[i].fromCodeScheme, gsmBci[i].toCodeScheme,
1047 gsmBci[i].selected);
1048 }
1049 closeRequest;
Wink Savillef4c4d362009-04-02 01:37:03 -07001050
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001051 if (status != NO_ERROR) {
1052 goto invalid;
1053 }
Wink Savillef4c4d362009-04-02 01:37:03 -07001054
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001055 s_callbacks.onRequest(pRI->pCI->requestNumber,
1056 gsmBciPtrs,
1057 num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *),
1058 pRI);
Wink Savillef4c4d362009-04-02 01:37:03 -07001059
1060#ifdef MEMSET_FREED
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001061 memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo));
1062 memset(gsmBciPtrs, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *));
Wink Savillef4c4d362009-04-02 01:37:03 -07001063#endif
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001064 }
Wink Savillef4c4d362009-04-02 01:37:03 -07001065
1066 return;
1067
1068invalid:
1069 invalidCommandBlock(pRI);
1070 return;
Wink Savillea592eeb2009-05-22 13:26:36 -07001071}
Wink Savillef4c4d362009-04-02 01:37:03 -07001072
Wink Savillea592eeb2009-05-22 13:26:36 -07001073static void
1074dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1075 int32_t t;
1076 status_t status;
1077 int32_t num;
1078
1079 status = p.readInt32(&num);
1080 if (status != NO_ERROR) {
1081 goto invalid;
1082 }
1083
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001084 {
1085 RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num];
1086 RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num];
Wink Savillea592eeb2009-05-22 13:26:36 -07001087
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001088 startRequest;
1089 for (int i = 0 ; i < num ; i++ ) {
1090 cdmaBciPtrs[i] = &cdmaBci[i];
Wink Savillea592eeb2009-05-22 13:26:36 -07001091
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001092 status = p.readInt32(&t);
1093 cdmaBci[i].service_category = (int) t;
Wink Savillea592eeb2009-05-22 13:26:36 -07001094
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001095 status = p.readInt32(&t);
1096 cdmaBci[i].language = (int) t;
Wink Savillea592eeb2009-05-22 13:26:36 -07001097
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001098 status = p.readInt32(&t);
1099 cdmaBci[i].selected = (uint8_t) t;
Wink Savillea592eeb2009-05-22 13:26:36 -07001100
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001101 appendPrintBuf("%s [%d: service_category=%d, language =%d, \
1102 entries.bSelected =%d]", printBuf, i, cdmaBci[i].service_category,
1103 cdmaBci[i].language, cdmaBci[i].selected);
1104 }
1105 closeRequest;
Wink Savillea592eeb2009-05-22 13:26:36 -07001106
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001107 if (status != NO_ERROR) {
1108 goto invalid;
1109 }
Wink Savillea592eeb2009-05-22 13:26:36 -07001110
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001111 s_callbacks.onRequest(pRI->pCI->requestNumber,
1112 cdmaBciPtrs,
1113 num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *),
1114 pRI);
Wink Savillea592eeb2009-05-22 13:26:36 -07001115
1116#ifdef MEMSET_FREED
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001117 memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo));
1118 memset(cdmaBciPtrs, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *));
Wink Savillea592eeb2009-05-22 13:26:36 -07001119#endif
Kevin Schoedel96dcdbc2012-05-25 17:00:17 -04001120 }
Wink Savillea592eeb2009-05-22 13:26:36 -07001121
1122 return;
1123
1124invalid:
1125 invalidCommandBlock(pRI);
1126 return;
Wink Savillef4c4d362009-04-02 01:37:03 -07001127}
1128
1129static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) {
1130 RIL_CDMA_SMS_WriteArgs rcsw;
1131 int32_t t;
1132 uint32_t ut;
1133 uint8_t uct;
1134 status_t status;
1135 int32_t digitCount;
1136
1137 memset(&rcsw, 0, sizeof(rcsw));
1138
1139 status = p.readInt32(&t);
1140 rcsw.status = t;
Wink Savillea592eeb2009-05-22 13:26:36 -07001141
Wink Savillef4c4d362009-04-02 01:37:03 -07001142 status = p.readInt32(&t);
1143 rcsw.message.uTeleserviceID = (int) t;
1144
1145 status = p.read(&uct,sizeof(uct));
1146 rcsw.message.bIsServicePresent = (uint8_t) uct;
1147
1148 status = p.readInt32(&t);
1149 rcsw.message.uServicecategory = (int) t;
1150
1151 status = p.readInt32(&t);
1152 rcsw.message.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
1153
1154 status = p.readInt32(&t);
1155 rcsw.message.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
1156
1157 status = p.readInt32(&t);
1158 rcsw.message.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
1159
1160 status = p.readInt32(&t);
1161 rcsw.message.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
1162
1163 status = p.read(&uct,sizeof(uct));
1164 rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
1165
1166 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
1167 status = p.read(&uct,sizeof(uct));
1168 rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
1169 }
1170
Wink Savillea592eeb2009-05-22 13:26:36 -07001171 status = p.readInt32(&t);
Wink Savillef4c4d362009-04-02 01:37:03 -07001172 rcsw.message.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
1173
Wink Savillea592eeb2009-05-22 13:26:36 -07001174 status = p.read(&uct,sizeof(uct));
Wink Savillef4c4d362009-04-02 01:37:03 -07001175 rcsw.message.sSubAddress.odd = (uint8_t) uct;
1176
1177 status = p.read(&uct,sizeof(uct));
1178 rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
1179
1180 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
Wink Savillea592eeb2009-05-22 13:26:36 -07001181 status = p.read(&uct,sizeof(uct));
Wink Savillef4c4d362009-04-02 01:37:03 -07001182 rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
1183 }
1184
Wink Savillea592eeb2009-05-22 13:26:36 -07001185 status = p.readInt32(&t);
Wink Savillef4c4d362009-04-02 01:37:03 -07001186 rcsw.message.uBearerDataLen = (int) t;
1187
1188 for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
Wink Savillea592eeb2009-05-22 13:26:36 -07001189 status = p.read(&uct, sizeof(uct));
Wink Savillef4c4d362009-04-02 01:37:03 -07001190 rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
1191 }
1192
1193 if (status != NO_ERROR) {
1194 goto invalid;
1195 }
1196
1197 startRequest;
Wink Saville1b5fd232009-04-22 14:50:00 -07001198 appendPrintBuf("%sstatus=%d, message.uTeleserviceID=%d, message.bIsServicePresent=%d, \
1199 message.uServicecategory=%d, message.sAddress.digit_mode=%d, \
1200 message.sAddress.number_mode=%d, \
1201 message.sAddress.number_type=%d, ",
Wink Savillef4c4d362009-04-02 01:37:03 -07001202 printBuf, rcsw.status, rcsw.message.uTeleserviceID, rcsw.message.bIsServicePresent,
Wink Saville1b5fd232009-04-22 14:50:00 -07001203 rcsw.message.uServicecategory, rcsw.message.sAddress.digit_mode,
1204 rcsw.message.sAddress.number_mode,
1205 rcsw.message.sAddress.number_type);
Wink Savillef4c4d362009-04-02 01:37:03 -07001206 closeRequest;
1207
1208 printRequest(pRI->token, pRI->pCI->requestNumber);
1209
1210 s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI);
1211
1212#ifdef MEMSET_FREED
1213 memset(&rcsw, 0, sizeof(rcsw));
1214#endif
1215
1216 return;
1217
1218invalid:
1219 invalidCommandBlock(pRI);
1220 return;
1221
1222}
1223
Lorenzo Colitti4f81dcf2010-09-01 19:38:57 -07001224// For backwards compatibility in RIL_REQUEST_SETUP_DATA_CALL.
1225// Version 4 of the RIL interface adds a new PDP type parameter to support
1226// IPv6 and dual-stack PDP contexts. When dealing with a previous version of
1227// RIL, remove the parameter from the request.
1228static void dispatchDataCall(Parcel& p, RequestInfo *pRI) {
1229 // In RIL v3, REQUEST_SETUP_DATA_CALL takes 6 parameters.
1230 const int numParamsRilV3 = 6;
1231
1232 // The first bytes of the RIL parcel contain the request number and the
1233 // serial number - see processCommandBuffer(). Copy them over too.
1234 int pos = p.dataPosition();
1235
1236 int numParams = p.readInt32();
1237 if (s_callbacks.version < 4 && numParams > numParamsRilV3) {
1238 Parcel p2;
1239 p2.appendFrom(&p, 0, pos);
1240 p2.writeInt32(numParamsRilV3);
1241 for(int i = 0; i < numParamsRilV3; i++) {
1242 p2.writeString16(p.readString16());
1243 }
1244 p2.setDataPosition(pos);
1245 dispatchStrings(p2, pRI);
1246 } else {
Lorenzo Colitti57ce1f22010-09-13 12:23:50 -07001247 p.setDataPosition(pos);
Lorenzo Colitti4f81dcf2010-09-01 19:38:57 -07001248 dispatchStrings(p, pRI);
1249 }
1250}
1251
Naveen Kalla2bc78d62011-12-07 16:22:53 -08001252// For backwards compatibility with RILs that dont support RIL_REQUEST_VOICE_RADIO_TECH.
1253// When all RILs handle this request, this function can be removed and
1254// the request can be sent directly to the RIL using dispatchVoid.
1255static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) {
1256 RIL_RadioState state = s_callbacks.onStateRequest();
1257
1258 if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
1259 RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1260 }
1261
1262 // RILs that support RADIO_STATE_ON should support this request.
1263 if (RADIO_STATE_ON == state) {
1264 dispatchVoid(p, pRI);
1265 return;
1266 }
1267
1268 // For Older RILs, that do not support RADIO_STATE_ON, assume that they
1269 // will not support this new request either and decode Voice Radio Technology
1270 // from Radio State
1271 voiceRadioTech = decodeVoiceRadioTechnology(state);
1272
1273 if (voiceRadioTech < 0)
1274 RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
1275 else
1276 RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &voiceRadioTech, sizeof(int));
1277}
1278
1279// For backwards compatibility in RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:.
1280// When all RILs handle this request, this function can be removed and
1281// the request can be sent directly to the RIL using dispatchVoid.
1282static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) {
1283 RIL_RadioState state = s_callbacks.onStateRequest();
1284
1285 if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
1286 RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1287 }
1288
1289 // RILs that support RADIO_STATE_ON should support this request.
1290 if (RADIO_STATE_ON == state) {
1291 dispatchVoid(p, pRI);
1292 return;
1293 }
1294
1295 // For Older RILs, that do not support RADIO_STATE_ON, assume that they
1296 // will not support this new request either and decode CDMA Subscription Source
1297 // from Radio State
1298 cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state);
1299
1300 if (cdmaSubscriptionSource < 0)
1301 RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
1302 else
1303 RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int));
1304}
1305
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001306static int
Wink Savillef4c4d362009-04-02 01:37:03 -07001307blockingWrite(int fd, const void *buffer, size_t len) {
Wink Saville7f856802009-06-09 10:23:37 -07001308 size_t writeOffset = 0;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001309 const uint8_t *toWrite;
1310
1311 toWrite = (const uint8_t *)buffer;
1312
1313 while (writeOffset < len) {
1314 ssize_t written;
1315 do {
1316 written = write (fd, toWrite + writeOffset,
1317 len - writeOffset);
Banavathu, Srinivas Naik38884902011-07-05 20:04:25 +05301318 } while (written < 0 && ((errno == EINTR) || (errno == EAGAIN)));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001319
1320 if (written >= 0) {
1321 writeOffset += written;
1322 } else { // written < 0
Wink Saville8eb2a122012-11-19 16:05:13 -08001323 RLOGE ("RIL Response: unexpected error on write errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001324 close(fd);
1325 return -1;
1326 }
1327 }
1328
1329 return 0;
1330}
1331
1332static int
Wink Savillef4c4d362009-04-02 01:37:03 -07001333sendResponseRaw (const void *data, size_t dataSize) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001334 int fd = s_fdCommand;
1335 int ret;
1336 uint32_t header;
1337
1338 if (s_fdCommand < 0) {
1339 return -1;
1340 }
1341
1342 if (dataSize > MAX_COMMAND_BYTES) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001343 RLOGE("RIL: packet larger than %u (%u)",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001344 MAX_COMMAND_BYTES, (unsigned int )dataSize);
1345
1346 return -1;
1347 }
Wink Saville7f856802009-06-09 10:23:37 -07001348
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001349 pthread_mutex_lock(&s_writeMutex);
1350
1351 header = htonl(dataSize);
1352
1353 ret = blockingWrite(fd, (void *)&header, sizeof(header));
1354
1355 if (ret < 0) {
Jaikumar Ganesh084f6702009-08-18 16:40:29 -07001356 pthread_mutex_unlock(&s_writeMutex);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001357 return ret;
1358 }
1359
Kennyee1fadc2009-08-13 00:45:53 +08001360 ret = blockingWrite(fd, data, dataSize);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001361
1362 if (ret < 0) {
Jaikumar Ganesh084f6702009-08-18 16:40:29 -07001363 pthread_mutex_unlock(&s_writeMutex);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001364 return ret;
1365 }
1366
1367 pthread_mutex_unlock(&s_writeMutex);
1368
1369 return 0;
1370}
1371
1372static int
Wink Savillef4c4d362009-04-02 01:37:03 -07001373sendResponse (Parcel &p) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001374 printResponse;
1375 return sendResponseRaw(p.data(), p.dataSize());
1376}
1377
1378/** response is an int* pointing to an array of ints*/
Wink Saville7f856802009-06-09 10:23:37 -07001379
1380static int
Wink Savillef4c4d362009-04-02 01:37:03 -07001381responseInts(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001382 int numInts;
1383
1384 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001385 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001386 return RIL_ERRNO_INVALID_RESPONSE;
1387 }
1388 if (responselen % sizeof(int) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001389 RLOGE("invalid response length %d expected multiple of %d\n",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001390 (int)responselen, (int)sizeof(int));
1391 return RIL_ERRNO_INVALID_RESPONSE;
1392 }
1393
1394 int *p_int = (int *) response;
1395
1396 numInts = responselen / sizeof(int *);
1397 p.writeInt32 (numInts);
1398
1399 /* each int*/
1400 startResponse;
1401 for (int i = 0 ; i < numInts ; i++) {
1402 appendPrintBuf("%s%d,", printBuf, p_int[i]);
1403 p.writeInt32(p_int[i]);
1404 }
1405 removeLastChar;
1406 closeResponse;
1407
1408 return 0;
1409}
1410
Wink Saville43808972011-01-13 17:39:51 -08001411/** response is a char **, pointing to an array of char *'s
1412 The parcel will begin with the version */
1413static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) {
1414 p.writeInt32(version);
1415 return responseStrings(p, response, responselen);
1416}
1417
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001418/** response is a char **, pointing to an array of char *'s */
Wink Savillef4c4d362009-04-02 01:37:03 -07001419static int responseStrings(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001420 int numStrings;
Wink Saville7f856802009-06-09 10:23:37 -07001421
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001422 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001423 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001424 return RIL_ERRNO_INVALID_RESPONSE;
1425 }
1426 if (responselen % sizeof(char *) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001427 RLOGE("invalid response length %d expected multiple of %d\n",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001428 (int)responselen, (int)sizeof(char *));
1429 return RIL_ERRNO_INVALID_RESPONSE;
1430 }
1431
1432 if (response == NULL) {
1433 p.writeInt32 (0);
1434 } else {
1435 char **p_cur = (char **) response;
1436
1437 numStrings = responselen / sizeof(char *);
1438 p.writeInt32 (numStrings);
1439
1440 /* each string*/
1441 startResponse;
1442 for (int i = 0 ; i < numStrings ; i++) {
1443 appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
1444 writeStringToParcel (p, p_cur[i]);
1445 }
1446 removeLastChar;
1447 closeResponse;
1448 }
1449 return 0;
1450}
1451
1452
1453/**
Wink Saville7f856802009-06-09 10:23:37 -07001454 * NULL strings are accepted
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001455 * FIXME currently ignores responselen
1456 */
Wink Savillef4c4d362009-04-02 01:37:03 -07001457static int responseString(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001458 /* one string only */
1459 startResponse;
1460 appendPrintBuf("%s%s", printBuf, (char*)response);
1461 closeResponse;
1462
1463 writeStringToParcel(p, (const char *)response);
1464
1465 return 0;
1466}
1467
Wink Savillef4c4d362009-04-02 01:37:03 -07001468static int responseVoid(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001469 startResponse;
1470 removeLastChar;
1471 return 0;
1472}
1473
Wink Savillef4c4d362009-04-02 01:37:03 -07001474static int responseCallList(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001475 int num;
1476
1477 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001478 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001479 return RIL_ERRNO_INVALID_RESPONSE;
1480 }
1481
1482 if (responselen % sizeof (RIL_Call *) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001483 RLOGE("invalid response length %d expected multiple of %d\n",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001484 (int)responselen, (int)sizeof (RIL_Call *));
1485 return RIL_ERRNO_INVALID_RESPONSE;
1486 }
1487
1488 startResponse;
1489 /* number of call info's */
1490 num = responselen / sizeof(RIL_Call *);
1491 p.writeInt32(num);
1492
1493 for (int i = 0 ; i < num ; i++) {
1494 RIL_Call *p_cur = ((RIL_Call **) response)[i];
1495 /* each call info */
1496 p.writeInt32(p_cur->state);
1497 p.writeInt32(p_cur->index);
1498 p.writeInt32(p_cur->toa);
1499 p.writeInt32(p_cur->isMpty);
1500 p.writeInt32(p_cur->isMT);
1501 p.writeInt32(p_cur->als);
1502 p.writeInt32(p_cur->isVoice);
Wink Saville1b5fd232009-04-22 14:50:00 -07001503 p.writeInt32(p_cur->isVoicePrivacy);
1504 writeStringToParcel(p, p_cur->number);
John Wangff368742009-03-24 17:56:29 -07001505 p.writeInt32(p_cur->numberPresentation);
Wink Saville1b5fd232009-04-22 14:50:00 -07001506 writeStringToParcel(p, p_cur->name);
1507 p.writeInt32(p_cur->namePresentation);
Wink Saville3a4840b2010-04-07 13:29:58 -07001508 // Remove when partners upgrade to version 3
Wink Saville74fa3882009-12-22 15:35:41 -08001509 if ((s_callbacks.version < 3) || (p_cur->uusInfo == NULL || p_cur->uusInfo->uusData == NULL)) {
1510 p.writeInt32(0); /* UUS Information is absent */
1511 } else {
1512 RIL_UUS_Info *uusInfo = p_cur->uusInfo;
1513 p.writeInt32(1); /* UUS Information is present */
1514 p.writeInt32(uusInfo->uusType);
1515 p.writeInt32(uusInfo->uusDcs);
1516 p.writeInt32(uusInfo->uusLength);
1517 p.write(uusInfo->uusData, uusInfo->uusLength);
1518 }
Wink Saville3d54e742009-05-18 18:00:44 -07001519 appendPrintBuf("%s[id=%d,%s,toa=%d,",
John Wangff368742009-03-24 17:56:29 -07001520 printBuf,
Wink Saville1b5fd232009-04-22 14:50:00 -07001521 p_cur->index,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001522 callStateToString(p_cur->state),
Wink Saville3d54e742009-05-18 18:00:44 -07001523 p_cur->toa);
1524 appendPrintBuf("%s%s,%s,als=%d,%s,%s,",
1525 printBuf,
Wink Saville1b5fd232009-04-22 14:50:00 -07001526 (p_cur->isMpty)?"conf":"norm",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001527 (p_cur->isMT)?"mt":"mo",
1528 p_cur->als,
1529 (p_cur->isVoice)?"voc":"nonvoc",
Wink Saville3d54e742009-05-18 18:00:44 -07001530 (p_cur->isVoicePrivacy)?"evp":"noevp");
1531 appendPrintBuf("%s%s,cli=%d,name='%s',%d]",
1532 printBuf,
Wink Saville1b5fd232009-04-22 14:50:00 -07001533 p_cur->number,
1534 p_cur->numberPresentation,
1535 p_cur->name,
1536 p_cur->namePresentation);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001537 }
1538 removeLastChar;
1539 closeResponse;
1540
1541 return 0;
1542}
1543
Wink Savillef4c4d362009-04-02 01:37:03 -07001544static int responseSMS(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001545 if (response == NULL) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001546 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001547 return RIL_ERRNO_INVALID_RESPONSE;
1548 }
1549
1550 if (responselen != sizeof (RIL_SMS_Response) ) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001551 RLOGE("invalid response length %d expected %d",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001552 (int)responselen, (int)sizeof (RIL_SMS_Response));
1553 return RIL_ERRNO_INVALID_RESPONSE;
1554 }
1555
1556 RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response;
1557
1558 p.writeInt32(p_cur->messageRef);
1559 writeStringToParcel(p, p_cur->ackPDU);
Jaikumar Ganesh920c78f2009-06-04 10:53:15 -07001560 p.writeInt32(p_cur->errorCode);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001561
1562 startResponse;
Jaikumar Ganesh920c78f2009-06-04 10:53:15 -07001563 appendPrintBuf("%s%d,%s,%d", printBuf, p_cur->messageRef,
1564 (char*)p_cur->ackPDU, p_cur->errorCode);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001565 closeResponse;
1566
1567 return 0;
1568}
1569
Wink Savillec0114b32011-02-18 10:14:07 -08001570static int responseDataCallListV4(Parcel &p, void *response, size_t responselen)
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001571{
1572 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001573 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001574 return RIL_ERRNO_INVALID_RESPONSE;
1575 }
1576
Wink Savillec0114b32011-02-18 10:14:07 -08001577 if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001578 RLOGE("invalid response length %d expected multiple of %d",
Wink Savillec0114b32011-02-18 10:14:07 -08001579 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v4));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001580 return RIL_ERRNO_INVALID_RESPONSE;
1581 }
1582
Wink Savillec0114b32011-02-18 10:14:07 -08001583 int num = responselen / sizeof(RIL_Data_Call_Response_v4);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001584 p.writeInt32(num);
1585
Wink Savillec0114b32011-02-18 10:14:07 -08001586 RIL_Data_Call_Response_v4 *p_cur = (RIL_Data_Call_Response_v4 *) response;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001587 startResponse;
1588 int i;
1589 for (i = 0; i < num; i++) {
1590 p.writeInt32(p_cur[i].cid);
1591 p.writeInt32(p_cur[i].active);
1592 writeStringToParcel(p, p_cur[i].type);
Wink Savillec0114b32011-02-18 10:14:07 -08001593 // apn is not used, so don't send.
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001594 writeStringToParcel(p, p_cur[i].address);
Wink Savillec0114b32011-02-18 10:14:07 -08001595 appendPrintBuf("%s[cid=%d,%s,%s,%s],", printBuf,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001596 p_cur[i].cid,
1597 (p_cur[i].active==0)?"down":"up",
1598 (char*)p_cur[i].type,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001599 (char*)p_cur[i].address);
1600 }
1601 removeLastChar;
1602 closeResponse;
1603
1604 return 0;
1605}
1606
Wink Saville43808972011-01-13 17:39:51 -08001607static int responseDataCallList(Parcel &p, void *response, size_t responselen)
1608{
1609 // Write version
1610 p.writeInt32(s_callbacks.version);
1611
1612 if (s_callbacks.version < 5) {
Wink Savillec0114b32011-02-18 10:14:07 -08001613 return responseDataCallListV4(p, response, responselen);
Wink Saville43808972011-01-13 17:39:51 -08001614 } else {
1615 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001616 RLOGE("invalid response: NULL");
Wink Saville43808972011-01-13 17:39:51 -08001617 return RIL_ERRNO_INVALID_RESPONSE;
1618 }
1619
Wink Savillec0114b32011-02-18 10:14:07 -08001620 if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001621 RLOGE("invalid response length %d expected multiple of %d",
Wink Savillec0114b32011-02-18 10:14:07 -08001622 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
Wink Saville43808972011-01-13 17:39:51 -08001623 return RIL_ERRNO_INVALID_RESPONSE;
1624 }
1625
Wink Savillec0114b32011-02-18 10:14:07 -08001626 int num = responselen / sizeof(RIL_Data_Call_Response_v6);
Wink Saville43808972011-01-13 17:39:51 -08001627 p.writeInt32(num);
1628
Wink Savillec0114b32011-02-18 10:14:07 -08001629 RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
Wink Saville43808972011-01-13 17:39:51 -08001630 startResponse;
1631 int i;
1632 for (i = 0; i < num; i++) {
1633 p.writeInt32((int)p_cur[i].status);
Kazuhiro Ondobeb25b52011-06-17 16:26:45 -05001634 p.writeInt32(p_cur[i].suggestedRetryTime);
Wink Saville43808972011-01-13 17:39:51 -08001635 p.writeInt32(p_cur[i].cid);
1636 p.writeInt32(p_cur[i].active);
David 'Digit' Turneraf1298d2011-02-04 13:36:47 +01001637 writeStringToParcel(p, p_cur[i].type);
Wink Saville43808972011-01-13 17:39:51 -08001638 writeStringToParcel(p, p_cur[i].ifname);
1639 writeStringToParcel(p, p_cur[i].addresses);
1640 writeStringToParcel(p, p_cur[i].dnses);
Wink Savillec0114b32011-02-18 10:14:07 -08001641 writeStringToParcel(p, p_cur[i].gateways);
Naveen Kalla56384152011-11-16 11:12:37 -08001642 appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf,
Wink Saville43808972011-01-13 17:39:51 -08001643 p_cur[i].status,
Kazuhiro Ondobeb25b52011-06-17 16:26:45 -05001644 p_cur[i].suggestedRetryTime,
Wink Saville43808972011-01-13 17:39:51 -08001645 p_cur[i].cid,
1646 (p_cur[i].active==0)?"down":"up",
Naveen Kalla56384152011-11-16 11:12:37 -08001647 (char*)p_cur[i].type,
Wink Saville43808972011-01-13 17:39:51 -08001648 (char*)p_cur[i].ifname,
1649 (char*)p_cur[i].addresses,
Wink Savillec0114b32011-02-18 10:14:07 -08001650 (char*)p_cur[i].dnses,
1651 (char*)p_cur[i].gateways);
Wink Saville43808972011-01-13 17:39:51 -08001652 }
1653 removeLastChar;
1654 closeResponse;
1655 }
1656
1657 return 0;
1658}
1659
1660static int responseSetupDataCall(Parcel &p, void *response, size_t responselen)
1661{
1662 if (s_callbacks.version < 5) {
1663 return responseStringsWithVersion(s_callbacks.version, p, response, responselen);
1664 } else {
1665 return responseDataCallList(p, response, responselen);
1666 }
1667}
1668
Wink Savillef4c4d362009-04-02 01:37:03 -07001669static int responseRaw(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001670 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001671 RLOGE("invalid response: NULL with responselen != 0");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001672 return RIL_ERRNO_INVALID_RESPONSE;
1673 }
1674
1675 // The java code reads -1 size as null byte array
1676 if (response == NULL) {
Wink Saville7f856802009-06-09 10:23:37 -07001677 p.writeInt32(-1);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001678 } else {
1679 p.writeInt32(responselen);
1680 p.write(response, responselen);
1681 }
1682
1683 return 0;
1684}
1685
1686
Wink Savillef4c4d362009-04-02 01:37:03 -07001687static int responseSIM_IO(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001688 if (response == NULL) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001689 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001690 return RIL_ERRNO_INVALID_RESPONSE;
1691 }
1692
1693 if (responselen != sizeof (RIL_SIM_IO_Response) ) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001694 RLOGE("invalid response length was %d expected %d",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001695 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
1696 return RIL_ERRNO_INVALID_RESPONSE;
1697 }
1698
1699 RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response;
1700 p.writeInt32(p_cur->sw1);
1701 p.writeInt32(p_cur->sw2);
1702 writeStringToParcel(p, p_cur->simResponse);
1703
1704 startResponse;
1705 appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2,
1706 (char*)p_cur->simResponse);
1707 closeResponse;
1708
1709
1710 return 0;
1711}
1712
Wink Savillef4c4d362009-04-02 01:37:03 -07001713static int responseCallForwards(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001714 int num;
Wink Saville7f856802009-06-09 10:23:37 -07001715
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001716 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001717 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001718 return RIL_ERRNO_INVALID_RESPONSE;
1719 }
1720
1721 if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001722 RLOGE("invalid response length %d expected multiple of %d",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001723 (int)responselen, (int)sizeof(RIL_CallForwardInfo *));
1724 return RIL_ERRNO_INVALID_RESPONSE;
1725 }
1726
1727 /* number of call info's */
1728 num = responselen / sizeof(RIL_CallForwardInfo *);
1729 p.writeInt32(num);
1730
1731 startResponse;
1732 for (int i = 0 ; i < num ; i++) {
1733 RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i];
1734
1735 p.writeInt32(p_cur->status);
1736 p.writeInt32(p_cur->reason);
1737 p.writeInt32(p_cur->serviceClass);
1738 p.writeInt32(p_cur->toa);
1739 writeStringToParcel(p, p_cur->number);
1740 p.writeInt32(p_cur->timeSeconds);
1741 appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
1742 (p_cur->status==1)?"enable":"disable",
1743 p_cur->reason, p_cur->serviceClass, p_cur->toa,
1744 (char*)p_cur->number,
1745 p_cur->timeSeconds);
1746 }
1747 removeLastChar;
1748 closeResponse;
Wink Saville7f856802009-06-09 10:23:37 -07001749
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001750 return 0;
1751}
1752
Wink Savillef4c4d362009-04-02 01:37:03 -07001753static int responseSsn(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001754 if (response == NULL) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001755 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001756 return RIL_ERRNO_INVALID_RESPONSE;
1757 }
1758
1759 if (responselen != sizeof(RIL_SuppSvcNotification)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001760 RLOGE("invalid response length was %d expected %d",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001761 (int)responselen, (int)sizeof (RIL_SuppSvcNotification));
1762 return RIL_ERRNO_INVALID_RESPONSE;
1763 }
1764
1765 RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response;
1766 p.writeInt32(p_cur->notificationType);
1767 p.writeInt32(p_cur->code);
1768 p.writeInt32(p_cur->index);
1769 p.writeInt32(p_cur->type);
1770 writeStringToParcel(p, p_cur->number);
1771
1772 startResponse;
1773 appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf,
1774 (p_cur->notificationType==0)?"mo":"mt",
1775 p_cur->code, p_cur->index, p_cur->type,
1776 (char*)p_cur->number);
1777 closeResponse;
1778
1779 return 0;
1780}
1781
Wink Saville3d54e742009-05-18 18:00:44 -07001782static int responseCellList(Parcel &p, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001783 int num;
1784
1785 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001786 RLOGE("invalid response: NULL");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001787 return RIL_ERRNO_INVALID_RESPONSE;
1788 }
1789
1790 if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001791 RLOGE("invalid response length %d expected multiple of %d\n",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001792 (int)responselen, (int)sizeof (RIL_NeighboringCell *));
1793 return RIL_ERRNO_INVALID_RESPONSE;
1794 }
1795
1796 startResponse;
Wink Saville3d54e742009-05-18 18:00:44 -07001797 /* number of records */
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001798 num = responselen / sizeof(RIL_NeighboringCell *);
1799 p.writeInt32(num);
1800
1801 for (int i = 0 ; i < num ; i++) {
1802 RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i];
1803
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08001804 p.writeInt32(p_cur->rssi);
1805 writeStringToParcel (p, p_cur->cid);
1806
1807 appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf,
1808 p_cur->cid, p_cur->rssi);
1809 }
1810 removeLastChar;
1811 closeResponse;
1812
1813 return 0;
1814}
1815
Wink Saville3d54e742009-05-18 18:00:44 -07001816/**
1817 * Marshall the signalInfoRecord into the parcel if it exists.
1818 */
Wink Savillea592eeb2009-05-22 13:26:36 -07001819static void marshallSignalInfoRecord(Parcel &p,
1820 RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) {
Wink Saville3d54e742009-05-18 18:00:44 -07001821 p.writeInt32(p_signalInfoRecord.isPresent);
1822 p.writeInt32(p_signalInfoRecord.signalType);
1823 p.writeInt32(p_signalInfoRecord.alertPitch);
1824 p.writeInt32(p_signalInfoRecord.signal);
1825}
1826
Wink Savillea592eeb2009-05-22 13:26:36 -07001827static int responseCdmaInformationRecords(Parcel &p,
1828 void *response, size_t responselen) {
Wink Saville3d54e742009-05-18 18:00:44 -07001829 int num;
Wink Savillea592eeb2009-05-22 13:26:36 -07001830 char* string8 = NULL;
1831 int buffer_lenght;
1832 RIL_CDMA_InformationRecord *infoRec;
Wink Saville3d54e742009-05-18 18:00:44 -07001833
1834 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001835 RLOGE("invalid response: NULL");
Wink Saville3d54e742009-05-18 18:00:44 -07001836 return RIL_ERRNO_INVALID_RESPONSE;
1837 }
1838
Wink Savillea592eeb2009-05-22 13:26:36 -07001839 if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001840 RLOGE("invalid response length %d expected multiple of %d\n",
Wink Savillea592eeb2009-05-22 13:26:36 -07001841 (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
Wink Saville3d54e742009-05-18 18:00:44 -07001842 return RIL_ERRNO_INVALID_RESPONSE;
1843 }
1844
Wink Savillea592eeb2009-05-22 13:26:36 -07001845 RIL_CDMA_InformationRecords *p_cur =
1846 (RIL_CDMA_InformationRecords *) response;
1847 num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
Wink Saville3d54e742009-05-18 18:00:44 -07001848
1849 startResponse;
Wink Savillea592eeb2009-05-22 13:26:36 -07001850 p.writeInt32(num);
Wink Saville3d54e742009-05-18 18:00:44 -07001851
Wink Savillea592eeb2009-05-22 13:26:36 -07001852 for (int i = 0 ; i < num ; i++) {
1853 infoRec = &p_cur->infoRec[i];
1854 p.writeInt32(infoRec->name);
1855 switch (infoRec->name) {
Wink Saville3d54e742009-05-18 18:00:44 -07001856 case RIL_CDMA_DISPLAY_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001857 case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC:
1858 if (infoRec->rec.display.alpha_len >
1859 CDMA_ALPHA_INFO_BUFFER_LENGTH) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001860 RLOGE("invalid display info response length %d \
Wink Savillea592eeb2009-05-22 13:26:36 -07001861 expected not more than %d\n",
1862 (int)infoRec->rec.display.alpha_len,
1863 CDMA_ALPHA_INFO_BUFFER_LENGTH);
1864 return RIL_ERRNO_INVALID_RESPONSE;
Wink Saville3d54e742009-05-18 18:00:44 -07001865 }
Wink Savillea592eeb2009-05-22 13:26:36 -07001866 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
1867 * sizeof(char) );
1868 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
1869 string8[i] = infoRec->rec.display.alpha_buf[i];
1870 }
Wink Saville43808972011-01-13 17:39:51 -08001871 string8[(int)infoRec->rec.display.alpha_len] = '\0';
Wink Savillea592eeb2009-05-22 13:26:36 -07001872 writeStringToParcel(p, (const char*)string8);
1873 free(string8);
1874 string8 = NULL;
Wink Saville3d54e742009-05-18 18:00:44 -07001875 break;
1876 case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
Wink Saville3d54e742009-05-18 18:00:44 -07001877 case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
Wink Saville3d54e742009-05-18 18:00:44 -07001878 case RIL_CDMA_CONNECTED_NUMBER_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001879 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001880 RLOGE("invalid display info response length %d \
Wink Savillea592eeb2009-05-22 13:26:36 -07001881 expected not more than %d\n",
1882 (int)infoRec->rec.number.len,
1883 CDMA_NUMBER_INFO_BUFFER_LENGTH);
1884 return RIL_ERRNO_INVALID_RESPONSE;
Wink Saville3d54e742009-05-18 18:00:44 -07001885 }
Wink Savillea592eeb2009-05-22 13:26:36 -07001886 string8 = (char*) malloc((infoRec->rec.number.len + 1)
1887 * sizeof(char) );
1888 for (int i = 0 ; i < infoRec->rec.number.len; i++) {
1889 string8[i] = infoRec->rec.number.buf[i];
1890 }
Wink Saville43808972011-01-13 17:39:51 -08001891 string8[(int)infoRec->rec.number.len] = '\0';
Wink Savillea592eeb2009-05-22 13:26:36 -07001892 writeStringToParcel(p, (const char*)string8);
1893 free(string8);
1894 string8 = NULL;
1895 p.writeInt32(infoRec->rec.number.number_type);
1896 p.writeInt32(infoRec->rec.number.number_plan);
1897 p.writeInt32(infoRec->rec.number.pi);
1898 p.writeInt32(infoRec->rec.number.si);
Wink Saville3d54e742009-05-18 18:00:44 -07001899 break;
1900 case RIL_CDMA_SIGNAL_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001901 p.writeInt32(infoRec->rec.signal.isPresent);
1902 p.writeInt32(infoRec->rec.signal.signalType);
1903 p.writeInt32(infoRec->rec.signal.alertPitch);
1904 p.writeInt32(infoRec->rec.signal.signal);
1905
1906 appendPrintBuf("%sisPresent=%X, signalType=%X, \
1907 alertPitch=%X, signal=%X, ",
1908 printBuf, (int)infoRec->rec.signal.isPresent,
1909 (int)infoRec->rec.signal.signalType,
1910 (int)infoRec->rec.signal.alertPitch,
1911 (int)infoRec->rec.signal.signal);
1912 removeLastChar;
Wink Saville3d54e742009-05-18 18:00:44 -07001913 break;
1914 case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001915 if (infoRec->rec.redir.redirectingNumber.len >
1916 CDMA_NUMBER_INFO_BUFFER_LENGTH) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001917 RLOGE("invalid display info response length %d \
Wink Savillea592eeb2009-05-22 13:26:36 -07001918 expected not more than %d\n",
1919 (int)infoRec->rec.redir.redirectingNumber.len,
1920 CDMA_NUMBER_INFO_BUFFER_LENGTH);
1921 return RIL_ERRNO_INVALID_RESPONSE;
Wink Saville3d54e742009-05-18 18:00:44 -07001922 }
Wink Savillea592eeb2009-05-22 13:26:36 -07001923 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
1924 .len + 1) * sizeof(char) );
1925 for (int i = 0;
1926 i < infoRec->rec.redir.redirectingNumber.len;
1927 i++) {
1928 string8[i] = infoRec->rec.redir.redirectingNumber.buf[i];
1929 }
Wink Saville43808972011-01-13 17:39:51 -08001930 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
Wink Savillea592eeb2009-05-22 13:26:36 -07001931 writeStringToParcel(p, (const char*)string8);
1932 free(string8);
1933 string8 = NULL;
1934 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type);
1935 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan);
1936 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi);
1937 p.writeInt32(infoRec->rec.redir.redirectingNumber.si);
1938 p.writeInt32(infoRec->rec.redir.redirectingReason);
Wink Saville3d54e742009-05-18 18:00:44 -07001939 break;
1940 case RIL_CDMA_LINE_CONTROL_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001941 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded);
1942 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle);
1943 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse);
1944 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1945
1946 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \
1947 lineCtrlToggle=%d, lineCtrlReverse=%d, \
1948 lineCtrlPowerDenial=%d, ", printBuf,
1949 (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded,
1950 (int)infoRec->rec.lineCtrl.lineCtrlToggle,
1951 (int)infoRec->rec.lineCtrl.lineCtrlReverse,
1952 (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1953 removeLastChar;
Wink Saville3d54e742009-05-18 18:00:44 -07001954 break;
1955 case RIL_CDMA_T53_CLIR_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001956 p.writeInt32((int)(infoRec->rec.clir.cause));
Wink Saville3d54e742009-05-18 18:00:44 -07001957
Wink Savillea592eeb2009-05-22 13:26:36 -07001958 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause);
1959 removeLastChar;
Wink Saville3d54e742009-05-18 18:00:44 -07001960 break;
1961 case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC:
Wink Savillea592eeb2009-05-22 13:26:36 -07001962 p.writeInt32(infoRec->rec.audioCtrl.upLink);
1963 p.writeInt32(infoRec->rec.audioCtrl.downLink);
1964
1965 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf,
1966 infoRec->rec.audioCtrl.upLink,
1967 infoRec->rec.audioCtrl.downLink);
1968 removeLastChar;
Wink Saville3d54e742009-05-18 18:00:44 -07001969 break;
Wink Savillea592eeb2009-05-22 13:26:36 -07001970 case RIL_CDMA_T53_RELEASE_INFO_REC:
1971 // TODO(Moto): See David Krause, he has the answer:)
Wink Saville8eb2a122012-11-19 16:05:13 -08001972 RLOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE");
Wink Savillea592eeb2009-05-22 13:26:36 -07001973 return RIL_ERRNO_INVALID_RESPONSE;
1974 default:
Wink Saville8eb2a122012-11-19 16:05:13 -08001975 RLOGE("Incorrect name value");
Wink Savillea592eeb2009-05-22 13:26:36 -07001976 return RIL_ERRNO_INVALID_RESPONSE;
Wink Saville3d54e742009-05-18 18:00:44 -07001977 }
1978 }
Wink Savillea592eeb2009-05-22 13:26:36 -07001979 closeResponse;
Wink Saville3d54e742009-05-18 18:00:44 -07001980
Wink Savillea592eeb2009-05-22 13:26:36 -07001981 return 0;
Wink Saville3d54e742009-05-18 18:00:44 -07001982}
1983
Wink Savillea592eeb2009-05-22 13:26:36 -07001984static int responseRilSignalStrength(Parcel &p,
1985 void *response, size_t responselen) {
1986 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08001987 RLOGE("invalid response: NULL");
Wink Saville3d54e742009-05-18 18:00:44 -07001988 return RIL_ERRNO_INVALID_RESPONSE;
1989 }
1990
Wink Savillec0114b32011-02-18 10:14:07 -08001991 if (responselen >= sizeof (RIL_SignalStrength_v5)) {
1992 RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response);
Wink Saville3d54e742009-05-18 18:00:44 -07001993
Wink Saville3d54e742009-05-18 18:00:44 -07001994 p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
1995 p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
1996 p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
1997 p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
1998 p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
1999 p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
2000 p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
Wink Savillec0114b32011-02-18 10:14:07 -08002001 if (responselen >= sizeof (RIL_SignalStrength_v6)) {
2002 p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
Uma Maheswari Ramalingam9efcac52012-08-09 11:59:17 -07002003
2004 /*
2005 * ril version <=6 receives negative values for rsrp
2006 * workaround for backward compatibility
2007 */
2008 p_cur->LTE_SignalStrength.rsrp =
2009 ((s_callbacks.version <= 6) && (p_cur->LTE_SignalStrength.rsrp < 0 )) ?
2010 -(p_cur->LTE_SignalStrength.rsrp) : p_cur->LTE_SignalStrength.rsrp;
2011
Wink Savillec0114b32011-02-18 10:14:07 -08002012 p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
2013 p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
2014 p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
2015 p.writeInt32(p_cur->LTE_SignalStrength.cqi);
2016 } else {
2017 memset(&p_cur->LTE_SignalStrength, sizeof (RIL_LTE_SignalStrength), 0);
2018 }
johnwangfdf825f2009-05-22 15:50:34 -07002019
2020 startResponse;
Wink Savillea592eeb2009-05-22 13:26:36 -07002021 appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
Wink Savillec0114b32011-02-18 10:14:07 -08002022 CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
2023 EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
2024 EVDO_SS.signalNoiseRatio=%d,\
2025 LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
2026 LTE_SS.rssnr=%d,LTE_SS.cqi=%d]",
Wink Savillea592eeb2009-05-22 13:26:36 -07002027 printBuf,
2028 p_cur->GW_SignalStrength.signalStrength,
2029 p_cur->GW_SignalStrength.bitErrorRate,
2030 p_cur->CDMA_SignalStrength.dbm,
2031 p_cur->CDMA_SignalStrength.ecio,
2032 p_cur->EVDO_SignalStrength.dbm,
2033 p_cur->EVDO_SignalStrength.ecio,
Wink Savillec0114b32011-02-18 10:14:07 -08002034 p_cur->EVDO_SignalStrength.signalNoiseRatio,
2035 p_cur->LTE_SignalStrength.signalStrength,
2036 p_cur->LTE_SignalStrength.rsrp,
2037 p_cur->LTE_SignalStrength.rsrq,
2038 p_cur->LTE_SignalStrength.rssnr,
2039 p_cur->LTE_SignalStrength.cqi);
Wink Savillea592eeb2009-05-22 13:26:36 -07002040 closeResponse;
2041
Wink Saville3d54e742009-05-18 18:00:44 -07002042 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002043 RLOGE("invalid response length");
Wink Saville3d54e742009-05-18 18:00:44 -07002044 return RIL_ERRNO_INVALID_RESPONSE;
2045 }
2046
Wink Saville3d54e742009-05-18 18:00:44 -07002047 return 0;
2048}
2049
2050static int responseCallRing(Parcel &p, void *response, size_t responselen) {
2051 if ((response == NULL) || (responselen == 0)) {
2052 return responseVoid(p, response, responselen);
2053 } else {
2054 return responseCdmaSignalInfoRecord(p, response, responselen);
2055 }
2056}
2057
2058static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) {
2059 if (response == NULL || responselen == 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002060 RLOGE("invalid response: NULL");
Wink Saville3d54e742009-05-18 18:00:44 -07002061 return RIL_ERRNO_INVALID_RESPONSE;
2062 }
2063
2064 if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002065 RLOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n",
Wink Saville3d54e742009-05-18 18:00:44 -07002066 (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord));
2067 return RIL_ERRNO_INVALID_RESPONSE;
2068 }
2069
2070 startResponse;
2071
2072 RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response);
2073 marshallSignalInfoRecord(p, *p_cur);
2074
2075 appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\
2076 signal=%d]",
2077 printBuf,
2078 p_cur->isPresent,
2079 p_cur->signalType,
2080 p_cur->alertPitch,
2081 p_cur->signal);
2082
2083 closeResponse;
2084 return 0;
2085}
2086
Wink Savillea592eeb2009-05-22 13:26:36 -07002087static int responseCdmaCallWaiting(Parcel &p, void *response,
2088 size_t responselen) {
Wink Saville3d54e742009-05-18 18:00:44 -07002089 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002090 RLOGE("invalid response: NULL");
Wink Saville3d54e742009-05-18 18:00:44 -07002091 return RIL_ERRNO_INVALID_RESPONSE;
2092 }
2093
Wink Savillec0114b32011-02-18 10:14:07 -08002094 if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002095 RLOGW("Upgrade to ril version %d\n", RIL_VERSION);
Wink Savillec0114b32011-02-18 10:14:07 -08002096 }
2097
2098 RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response);
2099
2100 writeStringToParcel(p, p_cur->number);
2101 p.writeInt32(p_cur->numberPresentation);
2102 writeStringToParcel(p, p_cur->name);
2103 marshallSignalInfoRecord(p, p_cur->signalInfoRecord);
2104
2105 if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
2106 p.writeInt32(p_cur->number_type);
2107 p.writeInt32(p_cur->number_plan);
2108 } else {
2109 p.writeInt32(0);
2110 p.writeInt32(0);
Wink Saville3d54e742009-05-18 18:00:44 -07002111 }
2112
2113 startResponse;
Wink Saville3d54e742009-05-18 18:00:44 -07002114 appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\
2115 signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\
Wink Savillec0114b32011-02-18 10:14:07 -08002116 signal=%d,number_type=%d,number_plan=%d]",
Wink Saville3d54e742009-05-18 18:00:44 -07002117 printBuf,
2118 p_cur->number,
2119 p_cur->numberPresentation,
2120 p_cur->name,
2121 p_cur->signalInfoRecord.isPresent,
2122 p_cur->signalInfoRecord.signalType,
2123 p_cur->signalInfoRecord.alertPitch,
Wink Savillec0114b32011-02-18 10:14:07 -08002124 p_cur->signalInfoRecord.signal,
2125 p_cur->number_type,
2126 p_cur->number_plan);
Wink Saville3d54e742009-05-18 18:00:44 -07002127 closeResponse;
2128
2129 return 0;
2130}
2131
Alex Yakavenka45e740e2012-01-31 11:48:27 -08002132static int responseSimRefresh(Parcel &p, void *response, size_t responselen) {
2133 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002134 RLOGE("responseSimRefresh: invalid response: NULL");
Alex Yakavenka45e740e2012-01-31 11:48:27 -08002135 return RIL_ERRNO_INVALID_RESPONSE;
2136 }
2137
2138 startResponse;
2139 if (s_callbacks.version == 7) {
2140 RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response);
2141 p.writeInt32(p_cur->result);
2142 p.writeInt32(p_cur->ef_id);
2143 writeStringToParcel(p, p_cur->aid);
2144
2145 appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s",
2146 printBuf,
2147 p_cur->result,
2148 p_cur->ef_id,
2149 p_cur->aid);
2150 } else {
2151 int *p_cur = ((int *) response);
2152 p.writeInt32(p_cur[0]);
2153 p.writeInt32(p_cur[1]);
2154 writeStringToParcel(p, NULL);
2155
2156 appendPrintBuf("%sresult=%d, ef_id=%d",
2157 printBuf,
2158 p_cur[0],
2159 p_cur[1]);
2160 }
2161 closeResponse;
2162
2163 return 0;
2164}
2165
Wink Saville3d54e742009-05-18 18:00:44 -07002166static void triggerEvLoop() {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002167 int ret;
2168 if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
2169 /* trigger event loop to wakeup. No reason to do this,
2170 * if we're in the event loop thread */
2171 do {
2172 ret = write (s_fdWakeupWrite, " ", 1);
2173 } while (ret < 0 && errno == EINTR);
2174 }
2175}
2176
Wink Saville3d54e742009-05-18 18:00:44 -07002177static void rilEventAddWakeup(struct ril_event *ev) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002178 ril_event_add(ev);
2179 triggerEvLoop();
2180}
2181
Wink Savillefd729372011-02-22 16:19:39 -08002182static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) {
2183 p.writeInt32(num_apps);
2184 startResponse;
2185 for (int i = 0; i < num_apps; i++) {
2186 p.writeInt32(appStatus[i].app_type);
2187 p.writeInt32(appStatus[i].app_state);
2188 p.writeInt32(appStatus[i].perso_substate);
2189 writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr));
2190 writeStringToParcel(p, (const char*)
2191 (appStatus[i].app_label_ptr));
2192 p.writeInt32(appStatus[i].pin1_replaced);
2193 p.writeInt32(appStatus[i].pin1);
2194 p.writeInt32(appStatus[i].pin2);
2195 appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\
2196 aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],",
2197 printBuf,
2198 appStatus[i].app_type,
2199 appStatus[i].app_state,
2200 appStatus[i].perso_substate,
2201 appStatus[i].aid_ptr,
2202 appStatus[i].app_label_ptr,
2203 appStatus[i].pin1_replaced,
2204 appStatus[i].pin1,
2205 appStatus[i].pin2);
2206 }
2207 closeResponse;
2208}
2209
Wink Savillef4c4d362009-04-02 01:37:03 -07002210static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
2211 int i;
2212
2213 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002214 RLOGE("invalid response: NULL");
Wink Savillef4c4d362009-04-02 01:37:03 -07002215 return RIL_ERRNO_INVALID_RESPONSE;
2216 }
2217
Wink Saville2c1fb3a2011-03-19 13:42:45 -07002218 if (responselen == sizeof (RIL_CardStatus_v6)) {
Wink Savillefd729372011-02-22 16:19:39 -08002219 RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
Wink Savillef4c4d362009-04-02 01:37:03 -07002220
Wink Savillefd729372011-02-22 16:19:39 -08002221 p.writeInt32(p_cur->card_state);
2222 p.writeInt32(p_cur->universal_pin_state);
2223 p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2224 p.writeInt32(p_cur->cdma_subscription_app_index);
2225 p.writeInt32(p_cur->ims_subscription_app_index);
2226
2227 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
Wink Saville2c1fb3a2011-03-19 13:42:45 -07002228 } else if (responselen == sizeof (RIL_CardStatus_v5)) {
Wink Savillefd729372011-02-22 16:19:39 -08002229 RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
2230
2231 p.writeInt32(p_cur->card_state);
2232 p.writeInt32(p_cur->universal_pin_state);
2233 p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2234 p.writeInt32(p_cur->cdma_subscription_app_index);
2235 p.writeInt32(-1);
2236
2237 sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
Wink Saville2c1fb3a2011-03-19 13:42:45 -07002238 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002239 RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
Wink Saville2c1fb3a2011-03-19 13:42:45 -07002240 return RIL_ERRNO_INVALID_RESPONSE;
Wink Savillef4c4d362009-04-02 01:37:03 -07002241 }
Wink Savillef4c4d362009-04-02 01:37:03 -07002242
2243 return 0;
Wink Saville3d54e742009-05-18 18:00:44 -07002244}
Wink Savillef4c4d362009-04-02 01:37:03 -07002245
Wink Savillea592eeb2009-05-22 13:26:36 -07002246static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2247 int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
Wink Savillef4c4d362009-04-02 01:37:03 -07002248 p.writeInt32(num);
2249
Wink Savillef4c4d362009-04-02 01:37:03 -07002250 startResponse;
Wink Savillea592eeb2009-05-22 13:26:36 -07002251 RIL_GSM_BroadcastSmsConfigInfo **p_cur =
2252 (RIL_GSM_BroadcastSmsConfigInfo **) response;
2253 for (int i = 0; i < num; i++) {
2254 p.writeInt32(p_cur[i]->fromServiceId);
2255 p.writeInt32(p_cur[i]->toServiceId);
2256 p.writeInt32(p_cur[i]->fromCodeScheme);
2257 p.writeInt32(p_cur[i]->toCodeScheme);
2258 p.writeInt32(p_cur[i]->selected);
2259
2260 appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \
2261 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]",
2262 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId,
2263 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme,
2264 p_cur[i]->selected);
2265 }
Wink Savillef4c4d362009-04-02 01:37:03 -07002266 closeResponse;
2267
2268 return 0;
2269}
2270
Wink Savillea592eeb2009-05-22 13:26:36 -07002271static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2272 RIL_CDMA_BroadcastSmsConfigInfo **p_cur =
2273 (RIL_CDMA_BroadcastSmsConfigInfo **) response;
Wink Savillef4c4d362009-04-02 01:37:03 -07002274
Wink Savillea592eeb2009-05-22 13:26:36 -07002275 int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *);
2276 p.writeInt32(num);
Wink Savillef4c4d362009-04-02 01:37:03 -07002277
2278 startResponse;
Wink Savillea592eeb2009-05-22 13:26:36 -07002279 for (int i = 0 ; i < num ; i++ ) {
2280 p.writeInt32(p_cur[i]->service_category);
2281 p.writeInt32(p_cur[i]->language);
2282 p.writeInt32(p_cur[i]->selected);
Wink Savillef4c4d362009-04-02 01:37:03 -07002283
Wink Savillea592eeb2009-05-22 13:26:36 -07002284 appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \
2285 selected =%d], ",
2286 printBuf, i, p_cur[i]->service_category, p_cur[i]->language,
2287 p_cur[i]->selected);
Wink Savillef5903df2009-04-24 11:54:14 -07002288 }
Wink Savillea592eeb2009-05-22 13:26:36 -07002289 closeResponse;
Wink Savillef5903df2009-04-24 11:54:14 -07002290
Wink Savillef4c4d362009-04-02 01:37:03 -07002291 return 0;
2292}
2293
2294static int responseCdmaSms(Parcel &p, void *response, size_t responselen) {
2295 int num;
2296 int digitCount;
2297 int digitLimit;
2298 uint8_t uct;
2299 void* dest;
2300
Wink Saville8eb2a122012-11-19 16:05:13 -08002301 RLOGD("Inside responseCdmaSms");
Wink Savillef5903df2009-04-24 11:54:14 -07002302
Wink Savillef4c4d362009-04-02 01:37:03 -07002303 if (response == NULL && responselen != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002304 RLOGE("invalid response: NULL");
Wink Savillef4c4d362009-04-02 01:37:03 -07002305 return RIL_ERRNO_INVALID_RESPONSE;
2306 }
2307
Wink Savillef5903df2009-04-24 11:54:14 -07002308 if (responselen != sizeof(RIL_CDMA_SMS_Message)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002309 RLOGE("invalid response length was %d expected %d",
Wink Savillef5903df2009-04-24 11:54:14 -07002310 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message));
Wink Savillef4c4d362009-04-02 01:37:03 -07002311 return RIL_ERRNO_INVALID_RESPONSE;
2312 }
2313
2314 RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response;
2315 p.writeInt32(p_cur->uTeleserviceID);
2316 p.write(&(p_cur->bIsServicePresent),sizeof(uct));
2317 p.writeInt32(p_cur->uServicecategory);
2318 p.writeInt32(p_cur->sAddress.digit_mode);
2319 p.writeInt32(p_cur->sAddress.number_mode);
2320 p.writeInt32(p_cur->sAddress.number_type);
2321 p.writeInt32(p_cur->sAddress.number_plan);
2322 p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct));
2323 digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
2324 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2325 p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct));
2326 }
2327
2328 p.writeInt32(p_cur->sSubAddress.subaddressType);
2329 p.write(&(p_cur->sSubAddress.odd),sizeof(uct));
2330 p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct));
2331 digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
2332 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2333 p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct));
2334 }
2335
2336 digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
2337 p.writeInt32(p_cur->uBearerDataLen);
2338 for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2339 p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct));
2340 }
2341
2342 startResponse;
2343 appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
Wink Saville1b5fd232009-04-22 14:50:00 -07002344 sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ",
Wink Savillef4c4d362009-04-02 01:37:03 -07002345 printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory,
2346 p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type);
2347 closeResponse;
2348
2349 return 0;
2350}
2351
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002352/**
2353 * A write on the wakeup fd is done just to pop us out of select()
2354 * We empty the buffer here and then ril_event will reset the timers on the
2355 * way back down
2356 */
Wink Savillef4c4d362009-04-02 01:37:03 -07002357static void processWakeupCallback(int fd, short flags, void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002358 char buff[16];
2359 int ret;
2360
Wink Saville8eb2a122012-11-19 16:05:13 -08002361 RLOGV("processWakeupCallback");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002362
2363 /* empty our wakeup socket out */
2364 do {
2365 ret = read(s_fdWakeupRead, &buff, sizeof(buff));
Wink Saville7f856802009-06-09 10:23:37 -07002366 } while (ret > 0 || (ret < 0 && errno == EINTR));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002367}
2368
Wink Savillef4c4d362009-04-02 01:37:03 -07002369static void onCommandsSocketClosed() {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002370 int ret;
2371 RequestInfo *p_cur;
2372
2373 /* mark pending requests as "cancelled" so we dont report responses */
2374
2375 ret = pthread_mutex_lock(&s_pendingRequestsMutex);
2376 assert (ret == 0);
2377
2378 p_cur = s_pendingRequests;
2379
Wink Saville7f856802009-06-09 10:23:37 -07002380 for (p_cur = s_pendingRequests
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002381 ; p_cur != NULL
2382 ; p_cur = p_cur->p_next
2383 ) {
2384 p_cur->cancelled = 1;
2385 }
2386
2387 ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
2388 assert (ret == 0);
2389}
2390
Wink Savillef4c4d362009-04-02 01:37:03 -07002391static void processCommandsCallback(int fd, short flags, void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002392 RecordStream *p_rs;
2393 void *p_record;
2394 size_t recordlen;
2395 int ret;
2396
2397 assert(fd == s_fdCommand);
2398
2399 p_rs = (RecordStream *)param;
2400
2401 for (;;) {
2402 /* loop until EAGAIN/EINTR, end of stream, or other error */
2403 ret = record_stream_get_next(p_rs, &p_record, &recordlen);
2404
2405 if (ret == 0 && p_record == NULL) {
2406 /* end-of-stream */
2407 break;
2408 } else if (ret < 0) {
2409 break;
2410 } else if (ret == 0) { /* && p_record != NULL */
2411 processCommandBuffer(p_record, recordlen);
2412 }
2413 }
2414
2415 if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {
2416 /* fatal error or end-of-stream */
2417 if (ret != 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002418 RLOGE("error on reading command socket errno:%d\n", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002419 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002420 RLOGW("EOS. Closing command socket.");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002421 }
Wink Saville7f856802009-06-09 10:23:37 -07002422
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002423 close(s_fdCommand);
2424 s_fdCommand = -1;
2425
2426 ril_event_del(&s_commands_event);
2427
2428 record_stream_free(p_rs);
2429
2430 /* start listening for new connections again */
2431 rilEventAddWakeup(&s_listen_event);
2432
2433 onCommandsSocketClosed();
2434 }
2435}
2436
2437
Wink Savillef4c4d362009-04-02 01:37:03 -07002438static void onNewCommandConnect() {
Wink Saville5b9df332011-04-06 16:24:21 -07002439 // Inform we are connected and the ril version
Jake Hambya9c18d12011-04-12 23:32:08 -07002440 int rilVer = s_callbacks.version;
Wink Saville5b9df332011-04-06 16:24:21 -07002441 RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED,
2442 &rilVer, sizeof(rilVer));
2443
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002444 // implicit radio state changed
2445 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
2446 NULL, 0);
2447
2448 // Send last NITZ time data, in case it was missed
2449 if (s_lastNITZTimeData != NULL) {
2450 sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
2451
2452 free(s_lastNITZTimeData);
2453 s_lastNITZTimeData = NULL;
2454 }
2455
2456 // Get version string
2457 if (s_callbacks.getVersion != NULL) {
2458 const char *version;
2459 version = s_callbacks.getVersion();
Wink Saville8eb2a122012-11-19 16:05:13 -08002460 RLOGI("RIL Daemon version: %s\n", version);
Wink Saville7f856802009-06-09 10:23:37 -07002461
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002462 property_set(PROPERTY_RIL_IMPL, version);
2463 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002464 RLOGI("RIL Daemon version: unavailable\n");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002465 property_set(PROPERTY_RIL_IMPL, "unavailable");
2466 }
2467
2468}
2469
Wink Savillef4c4d362009-04-02 01:37:03 -07002470static void listenCallback (int fd, short flags, void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002471 int ret;
2472 int err;
2473 int is_phone_socket;
2474 RecordStream *p_rs;
2475
2476 struct sockaddr_un peeraddr;
2477 socklen_t socklen = sizeof (peeraddr);
2478
2479 struct ucred creds;
2480 socklen_t szCreds = sizeof(creds);
2481
2482 struct passwd *pwd = NULL;
2483
2484 assert (s_fdCommand < 0);
2485 assert (fd == s_fdListen);
Wink Saville7f856802009-06-09 10:23:37 -07002486
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002487 s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
2488
2489 if (s_fdCommand < 0 ) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002490 RLOGE("Error on accept() errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002491 /* start listening for new connections again */
2492 rilEventAddWakeup(&s_listen_event);
Wink Savillef4c4d362009-04-02 01:37:03 -07002493 return;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002494 }
2495
2496 /* check the credential of the other side and only accept socket from
2497 * phone process
Wink Saville7f856802009-06-09 10:23:37 -07002498 */
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002499 errno = 0;
2500 is_phone_socket = 0;
Wink Savillef4c4d362009-04-02 01:37:03 -07002501
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002502 err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
Wink Savillef4c4d362009-04-02 01:37:03 -07002503
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002504 if (err == 0 && szCreds > 0) {
Wink Savillef4c4d362009-04-02 01:37:03 -07002505 errno = 0;
2506 pwd = getpwuid(creds.uid);
2507 if (pwd != NULL) {
2508 if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
2509 is_phone_socket = 1;
2510 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002511 RLOGE("RILD can't accept socket from process %s", pwd->pw_name);
Wink Savillef4c4d362009-04-02 01:37:03 -07002512 }
2513 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002514 RLOGE("Error on getpwuid() errno: %d", errno);
Wink Savillef4c4d362009-04-02 01:37:03 -07002515 }
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002516 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002517 RLOGD("Error on getsockopt() errno: %d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002518 }
2519
2520 if ( !is_phone_socket ) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002521 RLOGE("RILD must accept socket from %s", PHONE_PROCESS);
Wink Saville7f856802009-06-09 10:23:37 -07002522
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002523 close(s_fdCommand);
2524 s_fdCommand = -1;
2525
2526 onCommandsSocketClosed();
2527
2528 /* start listening for new connections again */
2529 rilEventAddWakeup(&s_listen_event);
2530
2531 return;
2532 }
2533
2534 ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
2535
2536 if (ret < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002537 RLOGE ("Error setting O_NONBLOCK errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002538 }
2539
Wink Saville8eb2a122012-11-19 16:05:13 -08002540 RLOGI("libril: new connection");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002541
2542 p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
2543
Wink Saville7f856802009-06-09 10:23:37 -07002544 ril_event_set (&s_commands_event, s_fdCommand, 1,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002545 processCommandsCallback, p_rs);
2546
2547 rilEventAddWakeup (&s_commands_event);
2548
2549 onNewCommandConnect();
2550}
2551
2552static void freeDebugCallbackArgs(int number, char **args) {
2553 for (int i = 0; i < number; i++) {
2554 if (args[i] != NULL) {
2555 free(args[i]);
2556 }
2557 }
2558 free(args);
2559}
2560
Wink Savillef4c4d362009-04-02 01:37:03 -07002561static void debugCallback (int fd, short flags, void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002562 int acceptFD, option;
2563 struct sockaddr_un peeraddr;
2564 socklen_t socklen = sizeof (peeraddr);
2565 int data;
2566 unsigned int qxdm_data[6];
2567 const char *deactData[1] = {"1"};
2568 char *actData[1];
2569 RIL_Dial dialData;
2570 int hangupData[1] = {1};
2571 int number;
2572 char **args;
2573
2574 acceptFD = accept (fd, (sockaddr *) &peeraddr, &socklen);
2575
2576 if (acceptFD < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002577 RLOGE ("error accepting on debug port: %d\n", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002578 return;
2579 }
2580
2581 if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002582 RLOGE ("error reading on socket: number of Args: \n");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002583 return;
2584 }
2585 args = (char **) malloc(sizeof(char*) * number);
2586
2587 for (int i = 0; i < number; i++) {
2588 int len;
2589 if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002590 RLOGE ("error reading on socket: Len of Args: \n");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002591 freeDebugCallbackArgs(i, args);
2592 return;
2593 }
2594 // +1 for null-term
2595 args[i] = (char *) malloc((sizeof(char) * len) + 1);
Wink Saville7f856802009-06-09 10:23:37 -07002596 if (recv(acceptFD, args[i], sizeof(char) * len, 0)
Wink Saville1b5fd232009-04-22 14:50:00 -07002597 != (int)sizeof(char) * len) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002598 RLOGE ("error reading on socket: Args[%d] \n", i);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002599 freeDebugCallbackArgs(i, args);
2600 return;
2601 }
2602 char * buf = args[i];
2603 buf[len] = 0;
2604 }
2605
2606 switch (atoi(args[0])) {
2607 case 0:
Wink Saville8eb2a122012-11-19 16:05:13 -08002608 RLOGI ("Connection on debug port: issuing reset.");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002609 issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
2610 break;
2611 case 1:
Wink Saville8eb2a122012-11-19 16:05:13 -08002612 RLOGI ("Connection on debug port: issuing radio power off.");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002613 data = 0;
2614 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2615 // Close the socket
2616 close(s_fdCommand);
2617 s_fdCommand = -1;
2618 break;
2619 case 2:
Wink Saville8eb2a122012-11-19 16:05:13 -08002620 RLOGI ("Debug port: issuing unsolicited voice network change.");
Wink Savillec0114b32011-02-18 10:14:07 -08002621 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002622 NULL, 0);
2623 break;
2624 case 3:
Wink Saville8eb2a122012-11-19 16:05:13 -08002625 RLOGI ("Debug port: QXDM log enable.");
Xia Wangd855ef42010-07-27 17:26:55 -07002626 qxdm_data[0] = 65536; // head.func_tag
2627 qxdm_data[1] = 16; // head.len
2628 qxdm_data[2] = 1; // mode: 1 for 'start logging'
2629 qxdm_data[3] = 32; // log_file_size: 32megabytes
2630 qxdm_data[4] = 0; // log_mask
2631 qxdm_data[5] = 8; // log_max_fileindex
Wink Saville7f856802009-06-09 10:23:37 -07002632 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002633 6 * sizeof(int));
2634 break;
2635 case 4:
Wink Saville8eb2a122012-11-19 16:05:13 -08002636 RLOGI ("Debug port: QXDM log disable.");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002637 qxdm_data[0] = 65536;
2638 qxdm_data[1] = 16;
Xia Wangd855ef42010-07-27 17:26:55 -07002639 qxdm_data[2] = 0; // mode: 0 for 'stop logging'
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002640 qxdm_data[3] = 32;
2641 qxdm_data[4] = 0;
Xia Wangd855ef42010-07-27 17:26:55 -07002642 qxdm_data[5] = 8;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002643 issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2644 6 * sizeof(int));
2645 break;
2646 case 5:
Wink Saville8eb2a122012-11-19 16:05:13 -08002647 RLOGI("Debug port: Radio On");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002648 data = 1;
2649 issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2650 sleep(2);
2651 // Set network selection automatic.
2652 issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
2653 break;
2654 case 6:
Wink Saville8eb2a122012-11-19 16:05:13 -08002655 RLOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002656 actData[0] = args[1];
Wink Saville7f856802009-06-09 10:23:37 -07002657 issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002658 sizeof(actData));
2659 break;
2660 case 7:
Wink Saville8eb2a122012-11-19 16:05:13 -08002661 RLOGI("Debug port: Deactivate Data Call");
Wink Saville7f856802009-06-09 10:23:37 -07002662 issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002663 sizeof(deactData));
2664 break;
2665 case 8:
Wink Saville8eb2a122012-11-19 16:05:13 -08002666 RLOGI("Debug port: Dial Call");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002667 dialData.clir = 0;
2668 dialData.address = args[1];
2669 issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
2670 break;
2671 case 9:
Wink Saville8eb2a122012-11-19 16:05:13 -08002672 RLOGI("Debug port: Answer Call");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002673 issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
2674 break;
2675 case 10:
Wink Saville8eb2a122012-11-19 16:05:13 -08002676 RLOGI("Debug port: End Call");
Wink Saville7f856802009-06-09 10:23:37 -07002677 issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002678 sizeof(hangupData));
2679 break;
2680 default:
Wink Saville8eb2a122012-11-19 16:05:13 -08002681 RLOGE ("Invalid request");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002682 break;
2683 }
2684 freeDebugCallbackArgs(number, args);
2685 close(acceptFD);
2686}
2687
2688
Wink Savillef4c4d362009-04-02 01:37:03 -07002689static void userTimerCallback (int fd, short flags, void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002690 UserCallbackInfo *p_info;
2691
2692 p_info = (UserCallbackInfo *)param;
2693
2694 p_info->p_callback(p_info->userParam);
2695
2696
2697 // FIXME generalize this...there should be a cancel mechanism
2698 if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) {
2699 s_last_wake_timeout_info = NULL;
2700 }
2701
2702 free(p_info);
2703}
2704
2705
2706static void *
Wink Savillef4c4d362009-04-02 01:37:03 -07002707eventLoop(void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002708 int ret;
2709 int filedes[2];
2710
2711 ril_event_init();
2712
2713 pthread_mutex_lock(&s_startupMutex);
2714
2715 s_started = 1;
2716 pthread_cond_broadcast(&s_startupCond);
2717
2718 pthread_mutex_unlock(&s_startupMutex);
2719
2720 ret = pipe(filedes);
2721
2722 if (ret < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002723 RLOGE("Error in pipe() errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002724 return NULL;
2725 }
2726
2727 s_fdWakeupRead = filedes[0];
2728 s_fdWakeupWrite = filedes[1];
2729
2730 fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
2731
2732 ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
2733 processWakeupCallback, NULL);
2734
2735 rilEventAddWakeup (&s_wakeupfd_event);
2736
2737 // Only returns on error
2738 ril_event_loop();
Wink Saville8eb2a122012-11-19 16:05:13 -08002739 RLOGE ("error in event_loop_base errno:%d", errno);
Kazuhiro Ondo5cdc1352011-10-14 17:50:58 -05002740 // kill self to restart on error
2741 kill(0, SIGKILL);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002742
2743 return NULL;
2744}
2745
Wink Saville7f856802009-06-09 10:23:37 -07002746extern "C" void
Wink Savillef4c4d362009-04-02 01:37:03 -07002747RIL_startEventLoop(void) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002748 int ret;
2749 pthread_attr_t attr;
Wink Saville7f856802009-06-09 10:23:37 -07002750
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002751 /* spin up eventLoop thread and wait for it to get started */
2752 s_started = 0;
2753 pthread_mutex_lock(&s_startupMutex);
2754
2755 pthread_attr_init (&attr);
Wink Saville7f856802009-06-09 10:23:37 -07002756 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002757 ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
2758
2759 while (s_started == 0) {
2760 pthread_cond_wait(&s_startupCond, &s_startupMutex);
2761 }
2762
2763 pthread_mutex_unlock(&s_startupMutex);
2764
2765 if (ret < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002766 RLOGE("Failed to create dispatch thread errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002767 return;
2768 }
2769}
2770
2771// Used for testing purpose only.
2772extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) {
2773 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2774}
2775
Wink Saville7f856802009-06-09 10:23:37 -07002776extern "C" void
Wink Savillef4c4d362009-04-02 01:37:03 -07002777RIL_register (const RIL_RadioFunctions *callbacks) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002778 int ret;
2779 int flags;
2780
Wink Saville43808972011-01-13 17:39:51 -08002781 if (callbacks == NULL) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002782 RLOGE("RIL_register: RIL_RadioFunctions * null");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002783 return;
2784 }
Wink Saville43808972011-01-13 17:39:51 -08002785 if (callbacks->version < RIL_VERSION_MIN) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002786 RLOGE("RIL_register: version %d is to old, min version is %d",
Wink Saville43808972011-01-13 17:39:51 -08002787 callbacks->version, RIL_VERSION_MIN);
2788 return;
Wink Saville3a4840b2010-04-07 13:29:58 -07002789 }
Wink Saville43808972011-01-13 17:39:51 -08002790 if (callbacks->version > RIL_VERSION) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002791 RLOGE("RIL_register: version %d is too new, max version is %d",
Wink Saville43808972011-01-13 17:39:51 -08002792 callbacks->version, RIL_VERSION);
2793 return;
2794 }
Wink Saville8eb2a122012-11-19 16:05:13 -08002795 RLOGE("RIL_register: RIL version %d", callbacks->version);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002796
2797 if (s_registerCalled > 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002798 RLOGE("RIL_register has been called more than once. "
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002799 "Subsequent call ignored");
2800 return;
2801 }
2802
2803 memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2804
2805 s_registerCalled = 1;
2806
2807 // Little self-check
2808
Wink Savillef4c4d362009-04-02 01:37:03 -07002809 for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002810 assert(i == s_commands[i].requestNumber);
2811 }
2812
Wink Savillef4c4d362009-04-02 01:37:03 -07002813 for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) {
Wink Saville7f856802009-06-09 10:23:37 -07002814 assert(i + RIL_UNSOL_RESPONSE_BASE
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002815 == s_unsolResponses[i].requestNumber);
2816 }
2817
2818 // New rild impl calls RIL_startEventLoop() first
2819 // old standalone impl wants it here.
2820
2821 if (s_started == 0) {
2822 RIL_startEventLoop();
2823 }
2824
2825 // start listen socket
2826
2827#if 0
Wink Saville7f856802009-06-09 10:23:37 -07002828 ret = socket_local_server (SOCKET_NAME_RIL,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002829 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
2830
2831 if (ret < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002832 RLOGE("Unable to bind socket errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002833 exit (-1);
2834 }
2835 s_fdListen = ret;
2836
2837#else
2838 s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
2839 if (s_fdListen < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002840 RLOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002841 exit(-1);
2842 }
2843
2844 ret = listen(s_fdListen, 4);
2845
2846 if (ret < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002847 RLOGE("Failed to listen on control socket '%d': %s",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002848 s_fdListen, strerror(errno));
2849 exit(-1);
2850 }
2851#endif
2852
2853
2854 /* note: non-persistent so we can accept only one connection at a time */
Wink Saville7f856802009-06-09 10:23:37 -07002855 ril_event_set (&s_listen_event, s_fdListen, false,
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002856 listenCallback, NULL);
2857
2858 rilEventAddWakeup (&s_listen_event);
2859
2860#if 1
2861 // start debug interface socket
2862
2863 s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
2864 if (s_fdDebug < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002865 RLOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002866 exit(-1);
2867 }
2868
2869 ret = listen(s_fdDebug, 4);
2870
2871 if (ret < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002872 RLOGE("Failed to listen on ril debug socket '%d': %s",
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002873 s_fdDebug, strerror(errno));
2874 exit(-1);
2875 }
2876
2877 ril_event_set (&s_debug_event, s_fdDebug, true,
2878 debugCallback, NULL);
2879
2880 rilEventAddWakeup (&s_debug_event);
2881#endif
2882
2883}
2884
2885static int
Wink Savillef4c4d362009-04-02 01:37:03 -07002886checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002887 int ret = 0;
Wink Saville7f856802009-06-09 10:23:37 -07002888
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002889 if (pRI == NULL) {
2890 return 0;
2891 }
2892
2893 pthread_mutex_lock(&s_pendingRequestsMutex);
2894
Wink Saville7f856802009-06-09 10:23:37 -07002895 for(RequestInfo **ppCur = &s_pendingRequests
2896 ; *ppCur != NULL
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002897 ; ppCur = &((*ppCur)->p_next)
2898 ) {
2899 if (pRI == *ppCur) {
2900 ret = 1;
2901
2902 *ppCur = (*ppCur)->p_next;
2903 break;
2904 }
2905 }
2906
2907 pthread_mutex_unlock(&s_pendingRequestsMutex);
2908
2909 return ret;
2910}
2911
2912
2913extern "C" void
Wink Savillef4c4d362009-04-02 01:37:03 -07002914RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002915 RequestInfo *pRI;
2916 int ret;
2917 size_t errorOffset;
2918
2919 pRI = (RequestInfo *)t;
2920
2921 if (!checkAndDequeueRequestInfo(pRI)) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002922 RLOGE ("RIL_onRequestComplete: invalid RIL_Token");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002923 return;
2924 }
2925
2926 if (pRI->local > 0) {
2927 // Locally issued command...void only!
2928 // response does not go back up the command socket
Wink Saville8eb2a122012-11-19 16:05:13 -08002929 RLOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002930
2931 goto done;
2932 }
2933
2934 appendPrintBuf("[%04d]< %s",
2935 pRI->token, requestToString(pRI->pCI->requestNumber));
2936
2937 if (pRI->cancelled == 0) {
2938 Parcel p;
2939
2940 p.writeInt32 (RESPONSE_SOLICITED);
2941 p.writeInt32 (pRI->token);
2942 errorOffset = p.dataPosition();
2943
2944 p.writeInt32 (e);
2945
johnwangb2a61842009-06-02 14:55:45 -07002946 if (response != NULL) {
2947 // there is a response payload, no matter success or not.
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002948 ret = pRI->pCI->responseFunction(p, response, responselen);
2949
2950 /* if an error occurred, rewind and mark it */
2951 if (ret != 0) {
2952 p.setDataPosition(errorOffset);
2953 p.writeInt32 (ret);
2954 }
johnwangb2a61842009-06-02 14:55:45 -07002955 }
2956
2957 if (e != RIL_E_SUCCESS) {
2958 appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002959 }
2960
2961 if (s_fdCommand < 0) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002962 RLOGD ("RIL onRequestComplete: Command channel closed");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002963 }
2964 sendResponse(p);
2965 }
2966
2967done:
2968 free(pRI);
2969}
2970
2971
2972static void
Wink Savillef4c4d362009-04-02 01:37:03 -07002973grabPartialWakeLock() {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002974 acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
2975}
2976
2977static void
Wink Savillef4c4d362009-04-02 01:37:03 -07002978releaseWakeLock() {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002979 release_wake_lock(ANDROID_WAKE_LOCK_NAME);
2980}
2981
2982/**
2983 * Timer callback to put us back to sleep before the default timeout
2984 */
2985static void
Wink Savillef4c4d362009-04-02 01:37:03 -07002986wakeTimeoutCallback (void *param) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002987 // We're using "param != NULL" as a cancellation mechanism
2988 if (param == NULL) {
Wink Saville8eb2a122012-11-19 16:05:13 -08002989 //RLOGD("wakeTimeout: releasing wake lock");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002990
2991 releaseWakeLock();
2992 } else {
Wink Saville8eb2a122012-11-19 16:05:13 -08002993 //RLOGD("wakeTimeout: releasing wake lock CANCELLED");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08002994 }
2995}
2996
Naveen Kalla2bc78d62011-12-07 16:22:53 -08002997static int
2998decodeVoiceRadioTechnology (RIL_RadioState radioState) {
2999 switch (radioState) {
3000 case RADIO_STATE_SIM_NOT_READY:
3001 case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
3002 case RADIO_STATE_SIM_READY:
3003 return RADIO_TECH_UMTS;
3004
3005 case RADIO_STATE_RUIM_NOT_READY:
3006 case RADIO_STATE_RUIM_READY:
3007 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
3008 case RADIO_STATE_NV_NOT_READY:
3009 case RADIO_STATE_NV_READY:
3010 return RADIO_TECH_1xRTT;
3011
3012 default:
Wink Saville8eb2a122012-11-19 16:05:13 -08003013 RLOGD("decodeVoiceRadioTechnology: Invoked with incorrect RadioState");
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003014 return -1;
3015 }
3016}
3017
3018static int
3019decodeCdmaSubscriptionSource (RIL_RadioState radioState) {
3020 switch (radioState) {
3021 case RADIO_STATE_SIM_NOT_READY:
3022 case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
3023 case RADIO_STATE_SIM_READY:
3024 case RADIO_STATE_RUIM_NOT_READY:
3025 case RADIO_STATE_RUIM_READY:
3026 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
3027 return CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM;
3028
3029 case RADIO_STATE_NV_NOT_READY:
3030 case RADIO_STATE_NV_READY:
3031 return CDMA_SUBSCRIPTION_SOURCE_NV;
3032
3033 default:
Wink Saville8eb2a122012-11-19 16:05:13 -08003034 RLOGD("decodeCdmaSubscriptionSource: Invoked with incorrect RadioState");
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003035 return -1;
3036 }
3037}
3038
3039static int
3040decodeSimStatus (RIL_RadioState radioState) {
3041 switch (radioState) {
3042 case RADIO_STATE_SIM_NOT_READY:
3043 case RADIO_STATE_RUIM_NOT_READY:
3044 case RADIO_STATE_NV_NOT_READY:
3045 case RADIO_STATE_NV_READY:
3046 return -1;
3047 case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
3048 case RADIO_STATE_SIM_READY:
3049 case RADIO_STATE_RUIM_READY:
3050 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
3051 return radioState;
3052 default:
Wink Saville8eb2a122012-11-19 16:05:13 -08003053 RLOGD("decodeSimStatus: Invoked with incorrect RadioState");
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003054 return -1;
3055 }
3056}
3057
3058static bool is3gpp2(int radioTech) {
3059 switch (radioTech) {
3060 case RADIO_TECH_IS95A:
3061 case RADIO_TECH_IS95B:
3062 case RADIO_TECH_1xRTT:
3063 case RADIO_TECH_EVDO_0:
3064 case RADIO_TECH_EVDO_A:
3065 case RADIO_TECH_EVDO_B:
3066 case RADIO_TECH_EHRPD:
3067 return true;
3068 default:
3069 return false;
3070 }
3071}
3072
3073/* If RIL sends SIM states or RUIM states, store the voice radio
3074 * technology and subscription source information so that they can be
3075 * returned when telephony framework requests them
3076 */
3077static RIL_RadioState
3078processRadioState(RIL_RadioState newRadioState) {
3079
3080 if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) {
3081 int newVoiceRadioTech;
3082 int newCdmaSubscriptionSource;
3083 int newSimStatus;
3084
3085 /* This is old RIL. Decode Subscription source and Voice Radio Technology
3086 from Radio State and send change notifications if there has been a change */
3087 newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState);
3088 if(newVoiceRadioTech != voiceRadioTech) {
3089 voiceRadioTech = newVoiceRadioTech;
3090 RIL_onUnsolicitedResponse (RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
3091 &voiceRadioTech, sizeof(voiceRadioTech));
3092 }
3093 if(is3gpp2(newVoiceRadioTech)) {
3094 newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState);
3095 if(newCdmaSubscriptionSource != cdmaSubscriptionSource) {
3096 cdmaSubscriptionSource = newCdmaSubscriptionSource;
3097 RIL_onUnsolicitedResponse (RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
3098 &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource));
3099 }
3100 }
3101 newSimStatus = decodeSimStatus(newRadioState);
3102 if(newSimStatus != simRuimStatus) {
3103 simRuimStatus = newSimStatus;
3104 RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
3105 }
3106
3107 /* Send RADIO_ON to telephony */
3108 newRadioState = RADIO_STATE_ON;
3109 }
3110
3111 return newRadioState;
3112}
3113
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003114extern "C"
3115void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
3116 size_t datalen)
3117{
3118 int unsolResponseIndex;
3119 int ret;
3120 int64_t timeReceived = 0;
3121 bool shouldScheduleTimeout = false;
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003122 RIL_RadioState newState;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003123
3124 if (s_registerCalled == 0) {
3125 // Ignore RIL_onUnsolicitedResponse before RIL_register
Wink Saville8eb2a122012-11-19 16:05:13 -08003126 RLOGW("RIL_onUnsolicitedResponse called before RIL_register");
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003127 return;
3128 }
Wink Saville7f856802009-06-09 10:23:37 -07003129
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003130 unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
3131
3132 if ((unsolResponseIndex < 0)
3133 || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) {
Wink Saville8eb2a122012-11-19 16:05:13 -08003134 RLOGE("unsupported unsolicited response code %d", unsolResponse);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003135 return;
3136 }
3137
3138 // Grab a wake lock if needed for this reponse,
3139 // as we exit we'll either release it immediately
3140 // or set a timer to release it later.
3141 switch (s_unsolResponses[unsolResponseIndex].wakeType) {
3142 case WAKE_PARTIAL:
3143 grabPartialWakeLock();
3144 shouldScheduleTimeout = true;
3145 break;
3146
3147 case DONT_WAKE:
3148 default:
3149 // No wake lock is grabed so don't set timeout
3150 shouldScheduleTimeout = false;
3151 break;
3152 }
3153
3154 // Mark the time this was received, doing this
3155 // after grabing the wakelock incase getting
3156 // the elapsedRealTime might cause us to goto
3157 // sleep.
3158 if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
3159 timeReceived = elapsedRealtime();
3160 }
3161
3162 appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
3163
3164 Parcel p;
3165
3166 p.writeInt32 (RESPONSE_UNSOLICITED);
3167 p.writeInt32 (unsolResponse);
3168
3169 ret = s_unsolResponses[unsolResponseIndex]
3170 .responseFunction(p, data, datalen);
3171 if (ret != 0) {
3172 // Problem with the response. Don't continue;
3173 goto error_exit;
3174 }
3175
3176 // some things get more payload
3177 switch(unsolResponse) {
3178 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003179 newState = processRadioState(s_callbacks.onStateRequest());
3180 p.writeInt32(newState);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003181 appendPrintBuf("%s {%s}", printBuf,
3182 radioStateToString(s_callbacks.onStateRequest()));
3183 break;
3184
3185
3186 case RIL_UNSOL_NITZ_TIME_RECEIVED:
3187 // Store the time that this was received so the
3188 // handler of this message can account for
3189 // the time it takes to arrive and process. In
3190 // particular the system has been known to sleep
3191 // before this message can be processed.
3192 p.writeInt64(timeReceived);
3193 break;
3194 }
3195
3196 ret = sendResponse(p);
3197 if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
3198
3199 // Unfortunately, NITZ time is not poll/update like everything
3200 // else in the system. So, if the upstream client isn't connected,
3201 // keep a copy of the last NITZ response (with receive time noted
3202 // above) around so we can deliver it when it is connected
3203
3204 if (s_lastNITZTimeData != NULL) {
3205 free (s_lastNITZTimeData);
3206 s_lastNITZTimeData = NULL;
3207 }
3208
3209 s_lastNITZTimeData = malloc(p.dataSize());
3210 s_lastNITZTimeDataSize = p.dataSize();
3211 memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
3212 }
3213
3214 // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
3215 // FIXME The java code should handshake here to release wake lock
3216
3217 if (shouldScheduleTimeout) {
3218 // Cancel the previous request
3219 if (s_last_wake_timeout_info != NULL) {
3220 s_last_wake_timeout_info->userParam = (void *)1;
3221 }
3222
3223 s_last_wake_timeout_info
3224 = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
3225 &TIMEVAL_WAKE_TIMEOUT);
3226 }
3227
3228 // Normal exit
3229 return;
3230
3231error_exit:
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003232 if (shouldScheduleTimeout) {
3233 releaseWakeLock();
3234 }
3235}
3236
Wink Saville7f856802009-06-09 10:23:37 -07003237/** FIXME generalize this if you track UserCAllbackInfo, clear it
3238 when the callback occurs
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003239*/
3240static UserCallbackInfo *
Wink Saville7f856802009-06-09 10:23:37 -07003241internalRequestTimedCallback (RIL_TimedCallback callback, void *param,
Dianne Hackborn0d9f0c02010-06-25 16:50:46 -07003242 const struct timeval *relativeTime)
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003243{
3244 struct timeval myRelativeTime;
3245 UserCallbackInfo *p_info;
3246
3247 p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
3248
Wink Saville7f856802009-06-09 10:23:37 -07003249 p_info->p_callback = callback;
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003250 p_info->userParam = param;
Dianne Hackborn0d9f0c02010-06-25 16:50:46 -07003251
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003252 if (relativeTime == NULL) {
3253 /* treat null parameter as a 0 relative time */
3254 memset (&myRelativeTime, 0, sizeof(myRelativeTime));
3255 } else {
3256 /* FIXME I think event_add's tv param is really const anyway */
3257 memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));
3258 }
3259
3260 ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);
3261
3262 ril_timer_add(&(p_info->event), &myRelativeTime);
3263
3264 triggerEvLoop();
3265 return p_info;
3266}
3267
Naveen Kalla7edd07c2010-06-21 18:54:47 -07003268
3269extern "C" void
Dianne Hackborn0d9f0c02010-06-25 16:50:46 -07003270RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,
3271 const struct timeval *relativeTime) {
3272 internalRequestTimedCallback (callback, param, relativeTime);
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003273}
3274
3275const char *
Wink Savillef4c4d362009-04-02 01:37:03 -07003276failCauseToString(RIL_Errno e) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003277 switch(e) {
3278 case RIL_E_SUCCESS: return "E_SUCCESS";
Robert Greenwalt2126ab22013-04-09 12:20:45 -07003279 case RIL_E_RADIO_NOT_AVAILABLE: return "E_RADIO_NOT_AVAILABLE";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003280 case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE";
3281 case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT";
3282 case RIL_E_SIM_PIN2: return "E_SIM_PIN2";
3283 case RIL_E_SIM_PUK2: return "E_SIM_PUK2";
3284 case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED";
3285 case RIL_E_CANCELLED: return "E_CANCELLED";
3286 case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL";
3287 case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
3288 case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY";
Wink Savillef4c4d362009-04-02 01:37:03 -07003289 case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT";
John Wang75534472010-04-20 15:11:42 -07003290 case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME";
Wink Saville7f856802009-06-09 10:23:37 -07003291#ifdef FEATURE_MULTIMODE_ANDROID
Wink Savillef4c4d362009-04-02 01:37:03 -07003292 case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
3293 case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
3294#endif
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003295 default: return "<unknown error>";
3296 }
3297}
3298
3299const char *
Wink Savillef4c4d362009-04-02 01:37:03 -07003300radioStateToString(RIL_RadioState s) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003301 switch(s) {
3302 case RADIO_STATE_OFF: return "RADIO_OFF";
3303 case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE";
3304 case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY";
3305 case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT";
3306 case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY";
Wink Savillef4c4d362009-04-02 01:37:03 -07003307 case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY";
3308 case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY";
3309 case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT";
3310 case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY";
3311 case RADIO_STATE_NV_READY:return"RADIO_NV_READY";
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003312 case RADIO_STATE_ON:return"RADIO_ON";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003313 default: return "<unknown state>";
3314 }
3315}
3316
3317const char *
Wink Savillef4c4d362009-04-02 01:37:03 -07003318callStateToString(RIL_CallState s) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003319 switch(s) {
3320 case RIL_CALL_ACTIVE : return "ACTIVE";
3321 case RIL_CALL_HOLDING: return "HOLDING";
3322 case RIL_CALL_DIALING: return "DIALING";
3323 case RIL_CALL_ALERTING: return "ALERTING";
3324 case RIL_CALL_INCOMING: return "INCOMING";
3325 case RIL_CALL_WAITING: return "WAITING";
3326 default: return "<unknown state>";
3327 }
3328}
3329
3330const char *
Wink Savillef4c4d362009-04-02 01:37:03 -07003331requestToString(int request) {
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003332/*
3333 cat libs/telephony/ril_commands.h \
3334 | egrep "^ *{RIL_" \
3335 | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
3336
3337
3338 cat libs/telephony/ril_unsol_commands.h \
3339 | egrep "^ *{RIL_" \
3340 | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
3341
3342*/
3343 switch(request) {
3344 case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
3345 case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
3346 case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
3347 case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
3348 case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
3349 case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
3350 case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
3351 case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
3352 case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
3353 case RIL_REQUEST_DIAL: return "DIAL";
3354 case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
3355 case RIL_REQUEST_HANGUP: return "HANGUP";
3356 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
3357 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
3358 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
3359 case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
3360 case RIL_REQUEST_UDUB: return "UDUB";
3361 case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
3362 case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
Wink Savillec0114b32011-02-18 10:14:07 -08003363 case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
3364 case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003365 case RIL_REQUEST_OPERATOR: return "OPERATOR";
3366 case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
3367 case RIL_REQUEST_DTMF: return "DTMF";
3368 case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
3369 case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
Wink Savillef4c4d362009-04-02 01:37:03 -07003370 case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003371 case RIL_REQUEST_SIM_IO: return "SIM_IO";
3372 case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
3373 case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
3374 case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
3375 case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
3376 case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
3377 case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
3378 case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
3379 case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
3380 case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
3381 case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
3382 case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
3383 case RIL_REQUEST_ANSWER: return "ANSWER";
Wink Savillef4c4d362009-04-02 01:37:03 -07003384 case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003385 case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
3386 case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
3387 case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
3388 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
3389 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
3390 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
3391 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
3392 case RIL_REQUEST_DTMF_START: return "DTMF_START";
3393 case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
3394 case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
3395 case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
3396 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
3397 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
3398 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
3399 case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
3400 case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
3401 case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
Wink Savillef4c4d362009-04-02 01:37:03 -07003402 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
3403 case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003404 case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
3405 case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
3406 case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
Wink Savillef4c4d362009-04-02 01:37:03 -07003407 case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
3408 case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003409 case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
3410 case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
3411 case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
3412 case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
3413 case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
3414 case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
3415 case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
3416 case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
Wink Savillec0114b32011-02-18 10:14:07 -08003417 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
Wink Savillef4c4d362009-04-02 01:37:03 -07003418 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
3419 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
3420 case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
3421 case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
3422 case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
3423 case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
3424 case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
3425 case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
3426 case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
3427 case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
Wink Savillea592eeb2009-05-22 13:26:36 -07003428 case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
3429 case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
3430 case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
3431 case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
3432 case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
Naveen Kalla03c1edf2009-09-23 11:18:35 -07003433 case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
Wink Savillef4c4d362009-04-02 01:37:03 -07003434 case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
3435 case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
3436 case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
3437 case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
jsh000a9fe2009-05-11 14:52:35 -07003438 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
3439 case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
3440 case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
jsh09a68ba2009-06-10 11:56:38 -07003441 case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
jsh563fd722010-06-08 16:52:24 -07003442 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
Wink Savillec0114b32011-02-18 10:14:07 -08003443 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
Jake Hambyfa8d5842011-08-19 16:22:18 -07003444 case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
Jake Hamby300105d2011-09-26 01:01:44 -07003445 case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
3446 case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003447 case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003448 case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
3449 case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
Wink Savillec0114b32011-02-18 10:14:07 -08003450 case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003451 case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
3452 case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
3453 case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
3454 case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
3455 case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
3456 case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
3457 case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
3458 case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
3459 case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
3460 case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
3461 case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
3462 case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
3463 case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
Wink Savillef4c4d362009-04-02 01:37:03 -07003464 case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003465 case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
Wink Savillef4c4d362009-04-02 01:37:03 -07003466 case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
3467 case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
3468 case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
3469 case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
Wink Saville3d54e742009-05-18 18:00:44 -07003470 case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
3471 case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
3472 case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
3473 case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
3474 case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
Jaikumar Ganeshaf6ecbf2009-04-29 13:27:51 -07003475 case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
John Wang5d621da2009-09-18 17:17:48 -07003476 case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
John Wang5909cf82010-01-29 00:18:54 -08003477 case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
Wink Savilleee274582011-04-16 15:05:49 -07003478 case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
Wink Savillec0114b32011-02-18 10:14:07 -08003479 case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
3480 case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
Wink Saville5b9df332011-04-06 16:24:21 -07003481 case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
Naveen Kalla2bc78d62011-12-07 16:22:53 -08003482 case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
The Android Open Source Project00f06fc2009-03-03 19:32:15 -08003483 default: return "<unknown request>";
3484 }
3485}
3486
3487} /* namespace android */