libril/ril.cpp

   1 /* //device/libs/telephony/ril.cpp
   2 **
   3 ** Copyright 2006, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 #define LOG_TAG "RILC"
  19
  20 #include <hardware_legacy/power.h>
  21 #include <telephony/ril.h>
  22 #include <telephony/ril_cdma_sms.h>
  23 #include <cutils/sockets.h>
  24 #include <cutils/jstring.h>
  25 #include <telephony/record_stream.h>
  26 #include <utils/Log.h>
  27 #include <utils/SystemClock.h>
  28 #include <pthread.h>
  29 #include <binder/Parcel.h>
  30 #include <cutils/jstring.h>
  31 #include <sys/types.h>
  32 #include <sys/limits.h>
  33 #include <sys/system_properties.h>
  34 #include <pwd.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <stdarg.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40 #include <fcntl.h>
  41 #include <time.h>
  42 #include <errno.h>
  43 #include <assert.h>
  44 #include <ctype.h>
  45 #include <alloca.h>
  46 #include <sys/un.h>
  47 #include <assert.h>
  48 #include <netinet/in.h>
  49 #include <cutils/properties.h>
  50 #include <RilSapSocket.h>
  51
  52 extern "C" void
  53 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen);
  54 namespace android {
  55
  56 #define PHONE_PROCESS "radio"
  57 #define BLUETOOTH_PROCESS "bluetooth"
  58
  59 #define SOCKET_NAME_RIL "rild"
  60 #define SOCKET2_NAME_RIL "rild2"
  61 #define SOCKET3_NAME_RIL "rild3"
  62 #define SOCKET4_NAME_RIL "rild4"
  63
  64 #define SOCKET_NAME_RIL_DEBUG "rild-debug"
  65
  66 #define ANDROID_WAKE_LOCK_NAME "radio-interface"
  67
  68 #define ANDROID_WAKE_LOCK_SECS 0
  69 #define ANDROID_WAKE_LOCK_USECS 200000
  70
  71 #define PROPERTY_RIL_IMPL "gsm.version.ril-impl"
  72
  73 // match with constant in RIL.java
  74 #define MAX_COMMAND_BYTES (8 * 1024)
  75
  76 // Basically: memset buffers that the client library
  77 // shouldn't be using anymore in an attempt to find
  78 // memory usage issues sooner.
  79 #define MEMSET_FREED 1
  80
  81 #define NUM_ELEMS(a)     (sizeof (a) / sizeof (a)[0])
  82
  83 #define MIN(a,b) ((a)<(b) ? (a) : (b))
  84
  85 /* Constants for response types */
  86 #define RESPONSE_SOLICITED 0
  87 #define RESPONSE_UNSOLICITED 1
  88
  89 /* Negative values for private RIL errno's */
  90 #define RIL_ERRNO_INVALID_RESPONSE -1
  91
  92 // request, response, and unsolicited msg print macro
  93 #define PRINTBUF_SIZE 8096
  94
  95 // Enable verbose logging
  96 #define VDBG 0
  97
  98 // Enable RILC log
  99 #define RILC_LOG 0
 100
 101 #if RILC_LOG
 102     #define startRequest           sprintf(printBuf, "(")
 103     #define closeRequest           sprintf(printBuf, "%s)", printBuf)
 104     #define printRequest(token, req)           \
 105             RLOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
 106
 107     #define startResponse           sprintf(printBuf, "%s {", printBuf)
 108     #define closeResponse           sprintf(printBuf, "%s}", printBuf)
 109     #define printResponse           RLOGD("%s", printBuf)
 110
 111     #define clearPrintBuf           printBuf[0] = 0
 112     #define removeLastChar          printBuf[strlen(printBuf)-1] = 0
 113     #define appendPrintBuf(x...)    sprintf(printBuf, x)
 114 #else
 115     #define startRequest
 116     #define closeRequest
 117     #define printRequest(token, req)
 118     #define startResponse
 119     #define closeResponse
 120     #define printResponse
 121     #define clearPrintBuf
 122     #define removeLastChar
 123     #define appendPrintBuf(x...)
 124 #endif
 125
 126 enum WakeType {DONT_WAKE, WAKE_PARTIAL};
 127
 128 typedef struct {
 129     int requestNumber;
 130     void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);
 131     int(*responseFunction) (Parcel &p, void *response, size_t responselen);
 132 } CommandInfo;
 133
 134 typedef struct {
 135     int requestNumber;
 136     int (*responseFunction) (Parcel &p, void *response, size_t responselen);
 137     WakeType wakeType;
 138 } UnsolResponseInfo;
 139
 140 typedef struct RequestInfo {
 141     int32_t token;      //this is not RIL_Token
 142     CommandInfo *pCI;
 143     struct RequestInfo *p_next;
 144     char cancelled;
 145     char local;         // responses to local commands do not go back to command process
 146     RIL_SOCKET_ID socket_id;
 147 } RequestInfo;
 148
 149 typedef struct UserCallbackInfo {
 150     RIL_TimedCallback p_callback;
 151     void *userParam;
 152     struct ril_event event;
 153     struct UserCallbackInfo *p_next;
 154 } UserCallbackInfo;
 155
 156 extern "C" const char * requestToString(int request);
 157 extern "C" const char * failCauseToString(RIL_Errno);
 158 extern "C" const char * callStateToString(RIL_CallState);
 159 extern "C" const char * radioStateToString(RIL_RadioState);
 160 extern "C" const char * rilSocketIdToString(RIL_SOCKET_ID socket_id);
 161
 162 extern "C"
 163 char rild[MAX_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL;
 164 /*******************************************************************/
 165
 166 RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
 167 static int s_registerCalled = 0;
 168
 169 static pthread_t s_tid_dispatch;
 170 static pthread_t s_tid_reader;
 171 static int s_started = 0;
 172
 173 static int s_fdDebug = -1;
 174 static int s_fdDebug_socket2 = -1;
 175
 176 static int s_fdWakeupRead;
 177 static int s_fdWakeupWrite;
 178
 179 static struct ril_event s_commands_event;
 180 static struct ril_event s_wakeupfd_event;
 181 static struct ril_event s_listen_event;
 182 static SocketListenParam s_ril_param_socket;
 183
 184 static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
 185 static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
 186 static RequestInfo *s_pendingRequests = NULL;
 187
 188 #if (SIM_COUNT >= 2)
 189 static struct ril_event s_commands_event_socket2;
 190 static struct ril_event s_listen_event_socket2;
 191 static SocketListenParam s_ril_param_socket2;
 192
 193 static pthread_mutex_t s_pendingRequestsMutex_socket2  = PTHREAD_MUTEX_INITIALIZER;
 194 static pthread_mutex_t s_writeMutex_socket2            = PTHREAD_MUTEX_INITIALIZER;
 195 static RequestInfo *s_pendingRequests_socket2          = NULL;
 196 #endif
 197
 198 #if (SIM_COUNT >= 3)
 199 static struct ril_event s_commands_event_socket3;
 200 static struct ril_event s_listen_event_socket3;
 201 static SocketListenParam s_ril_param_socket3;
 202
 203 static pthread_mutex_t s_pendingRequestsMutex_socket3  = PTHREAD_MUTEX_INITIALIZER;
 204 static pthread_mutex_t s_writeMutex_socket3            = PTHREAD_MUTEX_INITIALIZER;
 205 static RequestInfo *s_pendingRequests_socket3          = NULL;
 206 #endif
 207
 208 #if (SIM_COUNT >= 4)
 209 static struct ril_event s_commands_event_socket4;
 210 static struct ril_event s_listen_event_socket4;
 211 static SocketListenParam s_ril_param_socket4;
 212
 213 static pthread_mutex_t s_pendingRequestsMutex_socket4  = PTHREAD_MUTEX_INITIALIZER;
 214 static pthread_mutex_t s_writeMutex_socket4            = PTHREAD_MUTEX_INITIALIZER;
 215 static RequestInfo *s_pendingRequests_socket4          = NULL;
 216 #endif
 217
 218 static struct ril_event s_wake_timeout_event;
 219 static struct ril_event s_debug_event;
 220
 221
 222 static const struct timeval TIMEVAL_WAKE_TIMEOUT = {ANDROID_WAKE_LOCK_SECS,ANDROID_WAKE_LOCK_USECS};
 223
 224
 225 static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
 226 static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
 227
 228 static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
 229 static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
 230
 231 static RequestInfo *s_toDispatchHead = NULL;
 232 static RequestInfo *s_toDispatchTail = NULL;
 233
 234 static UserCallbackInfo *s_last_wake_timeout_info = NULL;
 235
 236 static void *s_lastNITZTimeData = NULL;
 237 static size_t s_lastNITZTimeDataSize;
 238
 239 #if RILC_LOG
 240     static char printBuf[PRINTBUF_SIZE];
 241 #endif
 242
 243 /*******************************************************************/
 244 static int sendResponse (Parcel &p, RIL_SOCKET_ID socket_id);
 245
 246 static void dispatchVoid (Parcel& p, RequestInfo *pRI);
 247 static void dispatchString (Parcel& p, RequestInfo *pRI);
 248 static void dispatchStrings (Parcel& p, RequestInfo *pRI);
 249 static void dispatchInts (Parcel& p, RequestInfo *pRI);
 250 static void dispatchDial (Parcel& p, RequestInfo *pRI);
 251 static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI);
 252 static void dispatchSIM_APDU (Parcel& p, RequestInfo *pRI);
 253 static void dispatchCallForward(Parcel& p, RequestInfo *pRI);
 254 static void dispatchRaw(Parcel& p, RequestInfo *pRI);
 255 static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI);
 256 static void dispatchDataCall (Parcel& p, RequestInfo *pRI);
 257 static void dispatchVoiceRadioTech (Parcel& p, RequestInfo *pRI);
 258 static void dispatchSetInitialAttachApn (Parcel& p, RequestInfo *pRI);
 259 static void dispatchCdmaSubscriptionSource (Parcel& p, RequestInfo *pRI);
 260
 261 static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI);
 262 static void dispatchImsSms(Parcel &p, RequestInfo *pRI);
 263 static void dispatchImsCdmaSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef);
 264 static void dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef);
 265 static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI);
 266 static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI);
 267 static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI);
 268 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI);
 269 static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI);
 270 static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI);
 271 static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI);
 272 static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI);
 273 static void dispatchDataProfile(Parcel &p, RequestInfo *pRI);
 274 static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI);
 275 static int responseInts(Parcel &p, void *response, size_t responselen);
 276 static int responseFailCause(Parcel &p, void *response, size_t responselen);
 277 static int responseStrings(Parcel &p, void *response, size_t responselen);
 278 static int responseString(Parcel &p, void *response, size_t responselen);
 279 static int responseVoid(Parcel &p, void *response, size_t responselen);
 280 static int responseCallList(Parcel &p, void *response, size_t responselen);
 281 static int responseSMS(Parcel &p, void *response, size_t responselen);
 282 static int responseSIM_IO(Parcel &p, void *response, size_t responselen);
 283 static int responseCallForwards(Parcel &p, void *response, size_t responselen);
 284 static int responseDataCallList(Parcel &p, void *response, size_t responselen);
 285 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen);
 286 static int responseRaw(Parcel &p, void *response, size_t responselen);
 287 static int responseSsn(Parcel &p, void *response, size_t responselen);
 288 static int responseSimStatus(Parcel &p, void *response, size_t responselen);
 289 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen);
 290 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen);
 291 static int responseCdmaSms(Parcel &p, void *response, size_t responselen);
 292 static int responseCellList(Parcel &p, void *response, size_t responselen);
 293 static int responseCdmaInformationRecords(Parcel &p,void *response, size_t responselen);
 294 static int responseRilSignalStrength(Parcel &p,void *response, size_t responselen);
 295 static int responseCallRing(Parcel &p, void *response, size_t responselen);
 296 static int responseCdmaSignalInfoRecord(Parcel &p,void *response, size_t responselen);
 297 static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen);
 298 static int responseSimRefresh(Parcel &p, void *response, size_t responselen);
 299 static int responseCellInfoList(Parcel &p, void *response, size_t responselen);
 300 static int responseHardwareConfig(Parcel &p, void *response, size_t responselen);
 301 static int responseDcRtInfo(Parcel &p, void *response, size_t responselen);
 302 static int responseRadioCapability(Parcel &p, void *response, size_t responselen);
 303 static int responseSSData(Parcel &p, void *response, size_t responselen);
 304 static int responseLceStatus(Parcel &p, void *response, size_t responselen);
 305 static int responseLceData(Parcel &p, void *response, size_t responselen);
 306 static int responseActivityData(Parcel &p, void *response, size_t responselen);
 307
 308 static int decodeVoiceRadioTechnology (RIL_RadioState radioState);
 309 static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
 310 static RIL_RadioState processRadioState(RIL_RadioState newRadioState);
 311
 312 static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType);
 313
 314 static bool isDebuggable();
 315
 316 #ifdef RIL_SHLIB
 317 #if defined(ANDROID_MULTI_SIM)
 318 extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
 319                                 size_t datalen, RIL_SOCKET_ID socket_id);
 320 #else
 321 extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
 322                                 size_t datalen);
 323 #endif
 324 #endif
 325
 326 #if defined(ANDROID_MULTI_SIM)
 327 #define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c), (d))
 328 #define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d), (e))
 329 #define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest(a)
 330 #else
 331 #define RIL_UNSOL_RESPONSE(a, b, c, d) RIL_onUnsolicitedResponse((a), (b), (c))
 332 #define CALL_ONREQUEST(a, b, c, d, e) s_callbacks.onRequest((a), (b), (c), (d))
 333 #define CALL_ONSTATEREQUEST(a) s_callbacks.onStateRequest()
 334 #endif
 335
 336 static UserCallbackInfo * internalRequestTimedCallback
 337     (RIL_TimedCallback callback, void *param,
 338         const struct timeval *relativeTime);
 339
 340 /** Index == requestNumber */
 341 static CommandInfo s_commands[] = {
 342 #include "ril_commands.h"
 343 };
 344
 345 static UnsolResponseInfo s_unsolResponses[] = {
 346 #include "ril_unsol_commands.h"
 347 };
 348
 349 /* For older RILs that do not support new commands RIL_REQUEST_VOICE_RADIO_TECH and
 350    RIL_UNSOL_VOICE_RADIO_TECH_CHANGED messages, decode the voice radio tech from
 351    radio state message and store it. Every time there is a change in Radio State
 352    check to see if voice radio tech changes and notify telephony
 353  */
 354 int voiceRadioTech = -1;
 355
 356 /* For older RILs that do not support new commands RIL_REQUEST_GET_CDMA_SUBSCRIPTION_SOURCE
 357    and RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED messages, decode the subscription
 358    source from radio state and store it. Every time there is a change in Radio State
 359    check to see if subscription source changed and notify telephony
 360  */
 361 int cdmaSubscriptionSource = -1;
 362
 363 /* For older RILs that do not send RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, decode the
 364    SIM/RUIM state from radio state and store it. Every time there is a change in Radio State,
 365    check to see if SIM/RUIM status changed and notify telephony
 366  */
 367 int simRuimStatus = -1;
 368
 369 static char * RIL_getRilSocketName() {
 370     return rild;
 371 }
 372
 373 extern "C"
 374 void RIL_setRilSocketName(const char * s) {
 375     strncpy(rild, s, MAX_SOCKET_NAME_LENGTH);
 376 }
 377
 378 static char *
 379 strdupReadString(Parcel &p) {
 380     size_t stringlen;
 381     const char16_t *s16;
 382
 383     s16 = p.readString16Inplace(&stringlen);
 384
 385     return strndup16to8(s16, stringlen);
 386 }
 387
 388 static status_t
 389 readStringFromParcelInplace(Parcel &p, char *str, size_t maxLen) {
 390     size_t s16Len;
 391     const char16_t *s16;
 392
 393     s16 = p.readString16Inplace(&s16Len);
 394     if (s16 == NULL) {
 395         return NO_MEMORY;
 396     }
 397     size_t strLen = strnlen16to8(s16, s16Len);
 398     if ((strLen + 1) > maxLen) {
 399         return NO_MEMORY;
 400     }
 401     if (strncpy16to8(str, s16, strLen) == NULL) {
 402         return NO_MEMORY;
 403     } else {
 404         return NO_ERROR;
 405     }
 406 }
 407
 408 static void writeStringToParcel(Parcel &p, const char *s) {
 409     char16_t *s16;
 410     size_t s16_len;
 411     s16 = strdup8to16(s, &s16_len);
 412     p.writeString16(s16, s16_len);
 413     free(s16);
 414 }
 415
 416
 417 static void
 418 memsetString (char *s) {
 419     if (s != NULL) {
 420         memset (s, 0, strlen(s));
 421     }
 422 }
 423
 424 void   nullParcelReleaseFunction (const uint8_t* data, size_t dataSize,
 425                                     const size_t* objects, size_t objectsSize,
 426                                         void* cookie) {
 427     // do nothing -- the data reference lives longer than the Parcel object
 428 }
 429
 430 /**
 431  * To be called from dispatch thread
 432  * Issue a single local request, ensuring that the response
 433  * is not sent back up to the command process
 434  */
 435 static void
 436 issueLocalRequest(int request, void *data, int len, RIL_SOCKET_ID socket_id) {
 437     RequestInfo *pRI;
 438     int ret;
 439     /* Hook for current context */
 440     /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
 441     pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
 442     /* pendingRequestsHook refer to &s_pendingRequests */
 443     RequestInfo**    pendingRequestsHook = &s_pendingRequests;
 444
 445 #if (SIM_COUNT == 2)
 446     if (socket_id == RIL_SOCKET_2) {
 447         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
 448         pendingRequestsHook = &s_pendingRequests_socket2;
 449     }
 450 #endif
 451
 452     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
 453
 454     pRI->local = 1;
 455     pRI->token = 0xffffffff;        // token is not used in this context
 456     pRI->pCI = &(s_commands[request]);
 457     pRI->socket_id = socket_id;
 458
 459     ret = pthread_mutex_lock(pendingRequestsMutexHook);
 460     assert (ret == 0);
 461
 462     pRI->p_next = *pendingRequestsHook;
 463     *pendingRequestsHook = pRI;
 464
 465     ret = pthread_mutex_unlock(pendingRequestsMutexHook);
 466     assert (ret == 0);
 467
 468     RLOGD("C[locl]> %s", requestToString(request));
 469
 470     CALL_ONREQUEST(request, data, len, pRI, pRI->socket_id);
 471 }
 472
 473
 474
 475 static int
 476 processCommandBuffer(void *buffer, size_t buflen, RIL_SOCKET_ID socket_id) {
 477     Parcel p;
 478     status_t status;
 479     int32_t request;
 480     int32_t token;
 481     RequestInfo *pRI;
 482     int ret;
 483     /* Hook for current context */
 484     /* pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
 485     pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
 486     /* pendingRequestsHook refer to &s_pendingRequests */
 487     RequestInfo**    pendingRequestsHook = &s_pendingRequests;
 488
 489     p.setData((uint8_t *) buffer, buflen);
 490
 491     // status checked at end
 492     status = p.readInt32(&request);
 493     status = p.readInt32 (&token);
 494
 495 #if (SIM_COUNT >= 2)
 496     if (socket_id == RIL_SOCKET_2) {
 497         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
 498         pendingRequestsHook = &s_pendingRequests_socket2;
 499     }
 500 #if (SIM_COUNT >= 3)
 501     else if (socket_id == RIL_SOCKET_3) {
 502         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
 503         pendingRequestsHook = &s_pendingRequests_socket3;
 504     }
 505 #endif
 506 #if (SIM_COUNT >= 4)
 507     else if (socket_id == RIL_SOCKET_4) {
 508         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
 509         pendingRequestsHook = &s_pendingRequests_socket4;
 510     }
 511 #endif
 512 #endif
 513
 514     if (status != NO_ERROR) {
 515         RLOGE("invalid request block");
 516         return 0;
 517     }
 518
 519     if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
 520         Parcel pErr;
 521         RLOGE("unsupported request code %d token %d", request, token);
 522         // FIXME this should perhaps return a response
 523         pErr.writeInt32 (RESPONSE_SOLICITED);
 524         pErr.writeInt32 (token);
 525         pErr.writeInt32 (RIL_E_GENERIC_FAILURE);
 526
 527         sendResponse(pErr, socket_id);
 528         return 0;
 529     }
 530
 531
 532     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
 533
 534     pRI->token = token;
 535     pRI->pCI = &(s_commands[request]);
 536     pRI->socket_id = socket_id;
 537
 538     ret = pthread_mutex_lock(pendingRequestsMutexHook);
 539     assert (ret == 0);
 540
 541     pRI->p_next = *pendingRequestsHook;
 542     *pendingRequestsHook = pRI;
 543
 544     ret = pthread_mutex_unlock(pendingRequestsMutexHook);
 545     assert (ret == 0);
 546
 547 /*    sLastDispatchedToken = token; */
 548
 549     pRI->pCI->dispatchFunction(p, pRI);
 550
 551     return 0;
 552 }
 553
 554 static void
 555 invalidCommandBlock (RequestInfo *pRI) {
 556     RLOGE("invalid command block for token %d request %s",
 557                 pRI->token, requestToString(pRI->pCI->requestNumber));
 558 }
 559
 560 /** Callee expects NULL */
 561 static void
 562 dispatchVoid (Parcel& p, RequestInfo *pRI) {
 563     clearPrintBuf;
 564     printRequest(pRI->token, pRI->pCI->requestNumber);
 565     CALL_ONREQUEST(pRI->pCI->requestNumber, NULL, 0, pRI, pRI->socket_id);
 566 }
 567
 568 /** Callee expects const char * */
 569 static void
 570 dispatchString (Parcel& p, RequestInfo *pRI) {
 571     status_t status;
 572     size_t datalen;
 573     size_t stringlen;
 574     char *string8 = NULL;
 575
 576     string8 = strdupReadString(p);
 577
 578     startRequest;
 579     appendPrintBuf("%s%s", printBuf, string8);
 580     closeRequest;
 581     printRequest(pRI->token, pRI->pCI->requestNumber);
 582
 583     CALL_ONREQUEST(pRI->pCI->requestNumber, string8,
 584                        sizeof(char *), pRI, pRI->socket_id);
 585
 586 #ifdef MEMSET_FREED
 587     memsetString(string8);
 588 #endif
 589
 590     free(string8);
 591     return;
 592 invalid:
 593     invalidCommandBlock(pRI);
 594     return;
 595 }
 596
 597 /** Callee expects const char ** */
 598 static void
 599 dispatchStrings (Parcel &p, RequestInfo *pRI) {
 600     int32_t countStrings;
 601     status_t status;
 602     size_t datalen;
 603     char **pStrings;
 604
 605     status = p.readInt32 (&countStrings);
 606
 607     if (status != NO_ERROR) {
 608         goto invalid;
 609     }
 610
 611     startRequest;
 612     if (countStrings == 0) {
 613         // just some non-null pointer
 614         pStrings = (char **)alloca(sizeof(char *));
 615         datalen = 0;
 616     } else if (((int)countStrings) == -1) {
 617         pStrings = NULL;
 618         datalen = 0;
 619     } else {
 620         datalen = sizeof(char *) * countStrings;
 621
 622         pStrings = (char **)alloca(datalen);
 623
 624         for (int i = 0 ; i < countStrings ; i++) {
 625             pStrings[i] = strdupReadString(p);
 626             appendPrintBuf("%s%s,", printBuf, pStrings[i]);
 627         }
 628     }
 629     removeLastChar;
 630     closeRequest;
 631     printRequest(pRI->token, pRI->pCI->requestNumber);
 632
 633     CALL_ONREQUEST(pRI->pCI->requestNumber, pStrings, datalen, pRI, pRI->socket_id);
 634
 635     if (pStrings != NULL) {
 636         for (int i = 0 ; i < countStrings ; i++) {
 637 #ifdef MEMSET_FREED
 638             memsetString (pStrings[i]);
 639 #endif
 640             free(pStrings[i]);
 641         }
 642
 643 #ifdef MEMSET_FREED
 644         memset(pStrings, 0, datalen);
 645 #endif
 646     }
 647
 648     return;
 649 invalid:
 650     invalidCommandBlock(pRI);
 651     return;
 652 }
 653
 654 /** Callee expects const int * */
 655 static void
 656 dispatchInts (Parcel &p, RequestInfo *pRI) {
 657     int32_t count;
 658     status_t status;
 659     size_t datalen;
 660     int *pInts;
 661
 662     status = p.readInt32 (&count);
 663
 664     if (status != NO_ERROR || count == 0) {
 665         goto invalid;
 666     }
 667
 668     datalen = sizeof(int) * count;
 669     pInts = (int *)alloca(datalen);
 670
 671     startRequest;
 672     for (int i = 0 ; i < count ; i++) {
 673         int32_t t;
 674
 675         status = p.readInt32(&t);
 676         pInts[i] = (int)t;
 677         appendPrintBuf("%s%d,", printBuf, t);
 678
 679         if (status != NO_ERROR) {
 680             goto invalid;
 681         }
 682    }
 683    removeLastChar;
 684    closeRequest;
 685    printRequest(pRI->token, pRI->pCI->requestNumber);
 686
 687    CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<int *>(pInts),
 688                        datalen, pRI, pRI->socket_id);
 689
 690 #ifdef MEMSET_FREED
 691     memset(pInts, 0, datalen);
 692 #endif
 693
 694     return;
 695 invalid:
 696     invalidCommandBlock(pRI);
 697     return;
 698 }
 699
 700
 701 /**
 702  * Callee expects const RIL_SMS_WriteArgs *
 703  * Payload is:
 704  *   int32_t status
 705  *   String pdu
 706  */
 707 static void
 708 dispatchSmsWrite (Parcel &p, RequestInfo *pRI) {
 709     RIL_SMS_WriteArgs args;
 710     int32_t t;
 711     status_t status;
 712
 713     RLOGD("dispatchSmsWrite");
 714     memset (&args, 0, sizeof(args));
 715
 716     status = p.readInt32(&t);
 717     args.status = (int)t;
 718
 719     args.pdu = strdupReadString(p);
 720
 721     if (status != NO_ERROR || args.pdu == NULL) {
 722         goto invalid;
 723     }
 724
 725     args.smsc = strdupReadString(p);
 726
 727     startRequest;
 728     appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status,
 729         (char*)args.pdu,  (char*)args.smsc);
 730     closeRequest;
 731     printRequest(pRI->token, pRI->pCI->requestNumber);
 732
 733     CALL_ONREQUEST(pRI->pCI->requestNumber, &args, sizeof(args), pRI, pRI->socket_id);
 734
 735 #ifdef MEMSET_FREED
 736     memsetString (args.pdu);
 737 #endif
 738
 739     free (args.pdu);
 740
 741 #ifdef MEMSET_FREED
 742     memset(&args, 0, sizeof(args));
 743 #endif
 744
 745     return;
 746 invalid:
 747     invalidCommandBlock(pRI);
 748     return;
 749 }
 750
 751 /**
 752  * Callee expects const RIL_Dial *
 753  * Payload is:
 754  *   String address
 755  *   int32_t clir
 756  */
 757 static void
 758 dispatchDial (Parcel &p, RequestInfo *pRI) {
 759     RIL_Dial dial;
 760     RIL_UUS_Info uusInfo;
 761     int32_t sizeOfDial;
 762     int32_t t;
 763     int32_t uusPresent;
 764     status_t status;
 765
 766     RLOGD("dispatchDial");
 767     memset (&dial, 0, sizeof(dial));
 768
 769     dial.address = strdupReadString(p);
 770
 771     status = p.readInt32(&t);
 772     dial.clir = (int)t;
 773
 774     if (status != NO_ERROR || dial.address == NULL) {
 775         goto invalid;
 776     }
 777
 778     if (s_callbacks.version < 3) { // Remove when partners upgrade to version 3
 779         uusPresent = 0;
 780         sizeOfDial = sizeof(dial) - sizeof(RIL_UUS_Info *);
 781     } else {
 782         status = p.readInt32(&uusPresent);
 783
 784         if (status != NO_ERROR) {
 785             goto invalid;
 786         }
 787
 788         if (uusPresent == 0) {
 789             dial.uusInfo = NULL;
 790         } else {
 791             int32_t len;
 792
 793             memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
 794
 795             status = p.readInt32(&t);
 796             uusInfo.uusType = (RIL_UUS_Type) t;
 797
 798             status = p.readInt32(&t);
 799             uusInfo.uusDcs = (RIL_UUS_DCS) t;
 800
 801             status = p.readInt32(&len);
 802             if (status != NO_ERROR) {
 803                 goto invalid;
 804             }
 805
 806             // The java code writes -1 for null arrays
 807             if (((int) len) == -1) {
 808                 uusInfo.uusData = NULL;
 809                 len = 0;
 810             } else {
 811                 uusInfo.uusData = (char*) p.readInplace(len);
 812             }
 813
 814             uusInfo.uusLength = len;
 815             dial.uusInfo = &uusInfo;
 816         }
 817         sizeOfDial = sizeof(dial);
 818     }
 819
 820     startRequest;
 821     appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir);
 822     if (uusPresent) {
 823         appendPrintBuf("%s,uusType=%d,uusDcs=%d,uusLen=%d", printBuf,
 824                 dial.uusInfo->uusType, dial.uusInfo->uusDcs,
 825                 dial.uusInfo->uusLength);
 826     }
 827     closeRequest;
 828     printRequest(pRI->token, pRI->pCI->requestNumber);
 829
 830     CALL_ONREQUEST(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI, pRI->socket_id);
 831
 832 #ifdef MEMSET_FREED
 833     memsetString (dial.address);
 834 #endif
 835
 836     free (dial.address);
 837
 838 #ifdef MEMSET_FREED
 839     memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
 840     memset(&dial, 0, sizeof(dial));
 841 #endif
 842
 843     return;
 844 invalid:
 845     invalidCommandBlock(pRI);
 846     return;
 847 }
 848
 849 /**
 850  * Callee expects const RIL_SIM_IO *
 851  * Payload is:
 852  *   int32_t command
 853  *   int32_t fileid
 854  *   String path
 855  *   int32_t p1, p2, p3
 856  *   String data
 857  *   String pin2
 858  *   String aidPtr
 859  */
 860 static void
 861 dispatchSIM_IO (Parcel &p, RequestInfo *pRI) {
 862     union RIL_SIM_IO {
 863         RIL_SIM_IO_v6 v6;
 864         RIL_SIM_IO_v5 v5;
 865     } simIO;
 866
 867     int32_t t;
 868     int size;
 869     status_t status;
 870
 871 #if VDBG
 872     RLOGD("dispatchSIM_IO");
 873 #endif
 874     memset (&simIO, 0, sizeof(simIO));
 875
 876     // note we only check status at the end
 877
 878     status = p.readInt32(&t);
 879     simIO.v6.command = (int)t;
 880
 881     status = p.readInt32(&t);
 882     simIO.v6.fileid = (int)t;
 883
 884     simIO.v6.path = strdupReadString(p);
 885
 886     status = p.readInt32(&t);
 887     simIO.v6.p1 = (int)t;
 888
 889     status = p.readInt32(&t);
 890     simIO.v6.p2 = (int)t;
 891
 892     status = p.readInt32(&t);
 893     simIO.v6.p3 = (int)t;
 894
 895     simIO.v6.data = strdupReadString(p);
 896     simIO.v6.pin2 = strdupReadString(p);
 897     simIO.v6.aidPtr = strdupReadString(p);
 898
 899     startRequest;
 900     appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s,aid=%s", printBuf,
 901         simIO.v6.command, simIO.v6.fileid, (char*)simIO.v6.path,
 902         simIO.v6.p1, simIO.v6.p2, simIO.v6.p3,
 903         (char*)simIO.v6.data,  (char*)simIO.v6.pin2, simIO.v6.aidPtr);
 904     closeRequest;
 905     printRequest(pRI->token, pRI->pCI->requestNumber);
 906
 907     if (status != NO_ERROR) {
 908         goto invalid;
 909     }
 910
 911     size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6);
 912     CALL_ONREQUEST(pRI->pCI->requestNumber, &simIO, size, pRI, pRI->socket_id);
 913
 914 #ifdef MEMSET_FREED
 915     memsetString (simIO.v6.path);
 916     memsetString (simIO.v6.data);
 917     memsetString (simIO.v6.pin2);
 918     memsetString (simIO.v6.aidPtr);
 919 #endif
 920
 921     free (simIO.v6.path);
 922     free (simIO.v6.data);
 923     free (simIO.v6.pin2);
 924     free (simIO.v6.aidPtr);
 925
 926 #ifdef MEMSET_FREED
 927     memset(&simIO, 0, sizeof(simIO));
 928 #endif
 929
 930     return;
 931 invalid:
 932     invalidCommandBlock(pRI);
 933     return;
 934 }
 935
 936 /**
 937  * Callee expects const RIL_SIM_APDU *
 938  * Payload is:
 939  *   int32_t sessionid
 940  *   int32_t cla
 941  *   int32_t instruction
 942  *   int32_t p1, p2, p3
 943  *   String data
 944  */
 945 static void
 946 dispatchSIM_APDU (Parcel &p, RequestInfo *pRI) {
 947     int32_t t;
 948     status_t status;
 949     RIL_SIM_APDU apdu;
 950
 951 #if VDBG
 952     RLOGD("dispatchSIM_APDU");
 953 #endif
 954     memset (&apdu, 0, sizeof(RIL_SIM_APDU));
 955
 956     // Note we only check status at the end. Any single failure leads to
 957     // subsequent reads filing.
 958     status = p.readInt32(&t);
 959     apdu.sessionid = (int)t;
 960
 961     status = p.readInt32(&t);
 962     apdu.cla = (int)t;
 963
 964     status = p.readInt32(&t);
 965     apdu.instruction = (int)t;
 966
 967     status = p.readInt32(&t);
 968     apdu.p1 = (int)t;
 969
 970     status = p.readInt32(&t);
 971     apdu.p2 = (int)t;
 972
 973     status = p.readInt32(&t);
 974     apdu.p3 = (int)t;
 975
 976     apdu.data = strdupReadString(p);
 977
 978     startRequest;
 979     appendPrintBuf("%ssessionid=%d,cla=%d,ins=%d,p1=%d,p2=%d,p3=%d,data=%s",
 980         printBuf, apdu.sessionid, apdu.cla, apdu.instruction, apdu.p1, apdu.p2,
 981         apdu.p3, (char*)apdu.data);
 982     closeRequest;
 983     printRequest(pRI->token, pRI->pCI->requestNumber);
 984
 985     if (status != NO_ERROR) {
 986         goto invalid;
 987     }
 988
 989     CALL_ONREQUEST(pRI->pCI->requestNumber, &apdu, sizeof(RIL_SIM_APDU), pRI, pRI->socket_id);
 990
 991 #ifdef MEMSET_FREED
 992     memsetString(apdu.data);
 993 #endif
 994     free(apdu.data);
 995
 996 #ifdef MEMSET_FREED
 997     memset(&apdu, 0, sizeof(RIL_SIM_APDU));
 998 #endif
 999
1000     return;
1001 invalid:
1002     invalidCommandBlock(pRI);
1003     return;
1004 }
1005
1006
1007 /**
1008  * Callee expects const RIL_CallForwardInfo *
1009  * Payload is:
1010  *  int32_t status/action
1011  *  int32_t reason
1012  *  int32_t serviceCode
1013  *  int32_t toa
1014  *  String number  (0 length -> null)
1015  *  int32_t timeSeconds
1016  */
1017 static void
1018 dispatchCallForward(Parcel &p, RequestInfo *pRI) {
1019     RIL_CallForwardInfo cff;
1020     int32_t t;
1021     status_t status;
1022
1023     RLOGD("dispatchCallForward");
1024     memset (&cff, 0, sizeof(cff));
1025
1026     // note we only check status at the end
1027
1028     status = p.readInt32(&t);
1029     cff.status = (int)t;
1030
1031     status = p.readInt32(&t);
1032     cff.reason = (int)t;
1033
1034     status = p.readInt32(&t);
1035     cff.serviceClass = (int)t;
1036
1037     status = p.readInt32(&t);
1038     cff.toa = (int)t;
1039
1040     cff.number = strdupReadString(p);
1041
1042     status = p.readInt32(&t);
1043     cff.timeSeconds = (int)t;
1044
1045     if (status != NO_ERROR) {
1046         goto invalid;
1047     }
1048
1049     // special case: number 0-length fields is null
1050
1051     if (cff.number != NULL && strlen (cff.number) == 0) {
1052         cff.number = NULL;
1053     }
1054
1055     startRequest;
1056     appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf,
1057         cff.status, cff.reason, cff.serviceClass, cff.toa,
1058         (char*)cff.number, cff.timeSeconds);
1059     closeRequest;
1060     printRequest(pRI->token, pRI->pCI->requestNumber);
1061
1062     CALL_ONREQUEST(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI, pRI->socket_id);
1063
1064 #ifdef MEMSET_FREED
1065     memsetString(cff.number);
1066 #endif
1067
1068     free (cff.number);
1069
1070 #ifdef MEMSET_FREED
1071     memset(&cff, 0, sizeof(cff));
1072 #endif
1073
1074     return;
1075 invalid:
1076     invalidCommandBlock(pRI);
1077     return;
1078 }
1079
1080
1081 static void
1082 dispatchRaw(Parcel &p, RequestInfo *pRI) {
1083     int32_t len;
1084     status_t status;
1085     const void *data;
1086
1087     status = p.readInt32(&len);
1088
1089     if (status != NO_ERROR) {
1090         goto invalid;
1091     }
1092
1093     // The java code writes -1 for null arrays
1094     if (((int)len) == -1) {
1095         data = NULL;
1096         len = 0;
1097     }
1098
1099     data = p.readInplace(len);
1100
1101     startRequest;
1102     appendPrintBuf("%sraw_size=%d", printBuf, len);
1103     closeRequest;
1104     printRequest(pRI->token, pRI->pCI->requestNumber);
1105
1106     CALL_ONREQUEST(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI, pRI->socket_id);
1107
1108     return;
1109 invalid:
1110     invalidCommandBlock(pRI);
1111     return;
1112 }
1113
1114 static status_t
1115 constructCdmaSms(Parcel &p, RequestInfo *pRI, RIL_CDMA_SMS_Message& rcsm) {
1116     int32_t  t;
1117     uint8_t ut;
1118     status_t status;
1119     int32_t digitCount;
1120     int digitLimit;
1121
1122     memset(&rcsm, 0, sizeof(rcsm));
1123
1124     status = p.readInt32(&t);
1125     rcsm.uTeleserviceID = (int) t;
1126
1127     status = p.read(&ut,sizeof(ut));
1128     rcsm.bIsServicePresent = (uint8_t) ut;
1129
1130     status = p.readInt32(&t);
1131     rcsm.uServicecategory = (int) t;
1132
1133     status = p.readInt32(&t);
1134     rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
1135
1136     status = p.readInt32(&t);
1137     rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
1138
1139     status = p.readInt32(&t);
1140     rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
1141
1142     status = p.readInt32(&t);
1143     rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
1144
1145     status = p.read(&ut,sizeof(ut));
1146     rcsm.sAddress.number_of_digits= (uint8_t) ut;
1147
1148     digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
1149     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
1150         status = p.read(&ut,sizeof(ut));
1151         rcsm.sAddress.digits[digitCount] = (uint8_t) ut;
1152     }
1153
1154     status = p.readInt32(&t);
1155     rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
1156
1157     status = p.read(&ut,sizeof(ut));
1158     rcsm.sSubAddress.odd = (uint8_t) ut;
1159
1160     status = p.read(&ut,sizeof(ut));
1161     rcsm.sSubAddress.number_of_digits = (uint8_t) ut;
1162
1163     digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
1164     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
1165         status = p.read(&ut,sizeof(ut));
1166         rcsm.sSubAddress.digits[digitCount] = (uint8_t) ut;
1167     }
1168
1169     status = p.readInt32(&t);
1170     rcsm.uBearerDataLen = (int) t;
1171
1172     digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
1173     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
1174         status = p.read(&ut, sizeof(ut));
1175         rcsm.aBearerData[digitCount] = (uint8_t) ut;
1176     }
1177
1178     if (status != NO_ERROR) {
1179         return status;
1180     }
1181
1182     startRequest;
1183     appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
1184             sAddress.digit_mode=%d, sAddress.Number_mode=%d, sAddress.number_type=%d, ",
1185             printBuf, rcsm.uTeleserviceID,rcsm.bIsServicePresent,rcsm.uServicecategory,
1186             rcsm.sAddress.digit_mode, rcsm.sAddress.number_mode,rcsm.sAddress.number_type);
1187     closeRequest;
1188
1189     printRequest(pRI->token, pRI->pCI->requestNumber);
1190
1191     return status;
1192 }
1193
1194 static void
1195 dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
1196     RIL_CDMA_SMS_Message rcsm;
1197
1198     RLOGD("dispatchCdmaSms");
1199     if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) {
1200         goto invalid;
1201     }
1202
1203     CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI, pRI->socket_id);
1204
1205 #ifdef MEMSET_FREED
1206     memset(&rcsm, 0, sizeof(rcsm));
1207 #endif
1208
1209     return;
1210
1211 invalid:
1212     invalidCommandBlock(pRI);
1213     return;
1214 }
1215
1216 static void
1217 dispatchImsCdmaSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef) {
1218     RIL_IMS_SMS_Message rism;
1219     RIL_CDMA_SMS_Message rcsm;
1220
1221     RLOGD("dispatchImsCdmaSms: retry=%d, messageRef=%d", retry, messageRef);
1222
1223     if (NO_ERROR != constructCdmaSms(p, pRI, rcsm)) {
1224         goto invalid;
1225     }
1226     memset(&rism, 0, sizeof(rism));
1227     rism.tech = RADIO_TECH_3GPP2;
1228     rism.retry = retry;
1229     rism.messageRef = messageRef;
1230     rism.message.cdmaMessage = &rcsm;
1231
1232     CALL_ONREQUEST(pRI->pCI->requestNumber, &rism,
1233             sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t)
1234             +sizeof(rcsm),pRI, pRI->socket_id);
1235
1236 #ifdef MEMSET_FREED
1237     memset(&rcsm, 0, sizeof(rcsm));
1238     memset(&rism, 0, sizeof(rism));
1239 #endif
1240
1241     return;
1242
1243 invalid:
1244     invalidCommandBlock(pRI);
1245     return;
1246 }
1247
1248 static void
1249 dispatchImsGsmSms(Parcel &p, RequestInfo *pRI, uint8_t retry, int32_t messageRef) {
1250     RIL_IMS_SMS_Message rism;
1251     int32_t countStrings;
1252     status_t status;
1253     size_t datalen;
1254     char **pStrings;
1255     RLOGD("dispatchImsGsmSms: retry=%d, messageRef=%d", retry, messageRef);
1256
1257     status = p.readInt32 (&countStrings);
1258
1259     if (status != NO_ERROR) {
1260         goto invalid;
1261     }
1262
1263     memset(&rism, 0, sizeof(rism));
1264     rism.tech = RADIO_TECH_3GPP;
1265     rism.retry = retry;
1266     rism.messageRef = messageRef;
1267
1268     startRequest;
1269     appendPrintBuf("%stech=%d, retry=%d, messageRef=%d, ", printBuf,
1270                     (int)rism.tech, (int)rism.retry, rism.messageRef);
1271     if (countStrings == 0) {
1272         // just some non-null pointer
1273         pStrings = (char **)alloca(sizeof(char *));
1274         datalen = 0;
1275     } else if (((int)countStrings) == -1) {
1276         pStrings = NULL;
1277         datalen = 0;
1278     } else {
1279         datalen = sizeof(char *) * countStrings;
1280
1281         pStrings = (char **)alloca(datalen);
1282
1283         for (int i = 0 ; i < countStrings ; i++) {
1284             pStrings[i] = strdupReadString(p);
1285             appendPrintBuf("%s%s,", printBuf, pStrings[i]);
1286         }
1287     }
1288     removeLastChar;
1289     closeRequest;
1290     printRequest(pRI->token, pRI->pCI->requestNumber);
1291
1292     rism.message.gsmMessage = pStrings;
1293     CALL_ONREQUEST(pRI->pCI->requestNumber, &rism,
1294             sizeof(RIL_RadioTechnologyFamily)+sizeof(uint8_t)+sizeof(int32_t)
1295             +datalen, pRI, pRI->socket_id);
1296
1297     if (pStrings != NULL) {
1298         for (int i = 0 ; i < countStrings ; i++) {
1299 #ifdef MEMSET_FREED
1300             memsetString (pStrings[i]);
1301 #endif
1302             free(pStrings[i]);
1303         }
1304
1305 #ifdef MEMSET_FREED
1306         memset(pStrings, 0, datalen);
1307 #endif
1308     }
1309
1310 #ifdef MEMSET_FREED
1311     memset(&rism, 0, sizeof(rism));
1312 #endif
1313     return;
1314 invalid:
1315     ALOGE("dispatchImsGsmSms invalid block");
1316     invalidCommandBlock(pRI);
1317     return;
1318 }
1319
1320 static void
1321 dispatchImsSms(Parcel &p, RequestInfo *pRI) {
1322     int32_t  t;
1323     status_t status = p.readInt32(&t);
1324     RIL_RadioTechnologyFamily format;
1325     uint8_t retry;
1326     int32_t messageRef;
1327
1328     RLOGD("dispatchImsSms");
1329     if (status != NO_ERROR) {
1330         goto invalid;
1331     }
1332     format = (RIL_RadioTechnologyFamily) t;
1333
1334     // read retry field
1335     status = p.read(&retry,sizeof(retry));
1336     if (status != NO_ERROR) {
1337         goto invalid;
1338     }
1339     // read messageRef field
1340     status = p.read(&messageRef,sizeof(messageRef));
1341     if (status != NO_ERROR) {
1342         goto invalid;
1343     }
1344
1345     if (RADIO_TECH_3GPP == format) {
1346         dispatchImsGsmSms(p, pRI, retry, messageRef);
1347     } else if (RADIO_TECH_3GPP2 == format) {
1348         dispatchImsCdmaSms(p, pRI, retry, messageRef);
1349     } else {
1350         ALOGE("requestImsSendSMS invalid format value =%d", format);
1351     }
1352
1353     return;
1354
1355 invalid:
1356     invalidCommandBlock(pRI);
1357     return;
1358 }
1359
1360 static void
1361 dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) {
1362     RIL_CDMA_SMS_Ack rcsa;
1363     int32_t  t;
1364     status_t status;
1365     int32_t digitCount;
1366
1367     RLOGD("dispatchCdmaSmsAck");
1368     memset(&rcsa, 0, sizeof(rcsa));
1369
1370     status = p.readInt32(&t);
1371     rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t;
1372
1373     status = p.readInt32(&t);
1374     rcsa.uSMSCauseCode = (int) t;
1375
1376     if (status != NO_ERROR) {
1377         goto invalid;
1378     }
1379
1380     startRequest;
1381     appendPrintBuf("%suErrorClass=%d, uTLStatus=%d, ",
1382             printBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode);
1383     closeRequest;
1384
1385     printRequest(pRI->token, pRI->pCI->requestNumber);
1386
1387     CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI, pRI->socket_id);
1388
1389 #ifdef MEMSET_FREED
1390     memset(&rcsa, 0, sizeof(rcsa));
1391 #endif
1392
1393     return;
1394
1395 invalid:
1396     invalidCommandBlock(pRI);
1397     return;
1398 }
1399
1400 static void
1401 dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1402     int32_t t;
1403     status_t status;
1404     int32_t num;
1405
1406     status = p.readInt32(&num);
1407     if (status != NO_ERROR) {
1408         goto invalid;
1409     }
1410
1411     {
1412         RIL_GSM_BroadcastSmsConfigInfo gsmBci[num];
1413         RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num];
1414
1415         startRequest;
1416         for (int i = 0 ; i < num ; i++ ) {
1417             gsmBciPtrs[i] = &gsmBci[i];
1418
1419             status = p.readInt32(&t);
1420             gsmBci[i].fromServiceId = (int) t;
1421
1422             status = p.readInt32(&t);
1423             gsmBci[i].toServiceId = (int) t;
1424
1425             status = p.readInt32(&t);
1426             gsmBci[i].fromCodeScheme = (int) t;
1427
1428             status = p.readInt32(&t);
1429             gsmBci[i].toCodeScheme = (int) t;
1430
1431             status = p.readInt32(&t);
1432             gsmBci[i].selected = (uint8_t) t;
1433
1434             appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId =%d, \
1435                   fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", printBuf, i,
1436                   gsmBci[i].fromServiceId, gsmBci[i].toServiceId,
1437                   gsmBci[i].fromCodeScheme, gsmBci[i].toCodeScheme,
1438                   gsmBci[i].selected);
1439         }
1440         closeRequest;
1441
1442         if (status != NO_ERROR) {
1443             goto invalid;
1444         }
1445
1446         CALL_ONREQUEST(pRI->pCI->requestNumber,
1447                               gsmBciPtrs,
1448                               num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *),
1449                               pRI, pRI->socket_id);
1450
1451 #ifdef MEMSET_FREED
1452         memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo));
1453         memset(gsmBciPtrs, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *));
1454 #endif
1455     }
1456
1457     return;
1458
1459 invalid:
1460     invalidCommandBlock(pRI);
1461     return;
1462 }
1463
1464 static void
1465 dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1466     int32_t t;
1467     status_t status;
1468     int32_t num;
1469
1470     status = p.readInt32(&num);
1471     if (status != NO_ERROR) {
1472         goto invalid;
1473     }
1474
1475     {
1476         RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num];
1477         RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num];
1478
1479         startRequest;
1480         for (int i = 0 ; i < num ; i++ ) {
1481             cdmaBciPtrs[i] = &cdmaBci[i];
1482
1483             status = p.readInt32(&t);
1484             cdmaBci[i].service_category = (int) t;
1485
1486             status = p.readInt32(&t);
1487             cdmaBci[i].language = (int) t;
1488
1489             status = p.readInt32(&t);
1490             cdmaBci[i].selected = (uint8_t) t;
1491
1492             appendPrintBuf("%s [%d: service_category=%d, language =%d, \
1493                   entries.bSelected =%d]", printBuf, i, cdmaBci[i].service_category,
1494                   cdmaBci[i].language, cdmaBci[i].selected);
1495         }
1496         closeRequest;
1497
1498         if (status != NO_ERROR) {
1499             goto invalid;
1500         }
1501
1502         CALL_ONREQUEST(pRI->pCI->requestNumber,
1503                               cdmaBciPtrs,
1504                               num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *),
1505                               pRI, pRI->socket_id);
1506
1507 #ifdef MEMSET_FREED
1508         memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo));
1509         memset(cdmaBciPtrs, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *));
1510 #endif
1511     }
1512
1513     return;
1514
1515 invalid:
1516     invalidCommandBlock(pRI);
1517     return;
1518 }
1519
1520 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) {
1521     RIL_CDMA_SMS_WriteArgs rcsw;
1522     int32_t  t;
1523     uint32_t ut;
1524     uint8_t  uct;
1525     status_t status;
1526     int32_t  digitCount;
1527
1528     memset(&rcsw, 0, sizeof(rcsw));
1529
1530     status = p.readInt32(&t);
1531     rcsw.status = t;
1532
1533     status = p.readInt32(&t);
1534     rcsw.message.uTeleserviceID = (int) t;
1535
1536     status = p.read(&uct,sizeof(uct));
1537     rcsw.message.bIsServicePresent = (uint8_t) uct;
1538
1539     status = p.readInt32(&t);
1540     rcsw.message.uServicecategory = (int) t;
1541
1542     status = p.readInt32(&t);
1543     rcsw.message.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
1544
1545     status = p.readInt32(&t);
1546     rcsw.message.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
1547
1548     status = p.readInt32(&t);
1549     rcsw.message.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
1550
1551     status = p.readInt32(&t);
1552     rcsw.message.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
1553
1554     status = p.read(&uct,sizeof(uct));
1555     rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
1556
1557     for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
1558         status = p.read(&uct,sizeof(uct));
1559         rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
1560     }
1561
1562     status = p.readInt32(&t);
1563     rcsw.message.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
1564
1565     status = p.read(&uct,sizeof(uct));
1566     rcsw.message.sSubAddress.odd = (uint8_t) uct;
1567
1568     status = p.read(&uct,sizeof(uct));
1569     rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
1570
1571     for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
1572         status = p.read(&uct,sizeof(uct));
1573         rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
1574     }
1575
1576     status = p.readInt32(&t);
1577     rcsw.message.uBearerDataLen = (int) t;
1578
1579     for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
1580         status = p.read(&uct, sizeof(uct));
1581         rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
1582     }
1583
1584     if (status != NO_ERROR) {
1585         goto invalid;
1586     }
1587
1588     startRequest;
1589     appendPrintBuf("%sstatus=%d, message.uTeleserviceID=%d, message.bIsServicePresent=%d, \
1590             message.uServicecategory=%d, message.sAddress.digit_mode=%d, \
1591             message.sAddress.number_mode=%d, \
1592             message.sAddress.number_type=%d, ",
1593             printBuf, rcsw.status, rcsw.message.uTeleserviceID, rcsw.message.bIsServicePresent,
1594             rcsw.message.uServicecategory, rcsw.message.sAddress.digit_mode,
1595             rcsw.message.sAddress.number_mode,
1596             rcsw.message.sAddress.number_type);
1597     closeRequest;
1598
1599     printRequest(pRI->token, pRI->pCI->requestNumber);
1600
1601     CALL_ONREQUEST(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI, pRI->socket_id);
1602
1603 #ifdef MEMSET_FREED
1604     memset(&rcsw, 0, sizeof(rcsw));
1605 #endif
1606
1607     return;
1608
1609 invalid:
1610     invalidCommandBlock(pRI);
1611     return;
1612
1613 }
1614
1615 // For backwards compatibility in RIL_REQUEST_SETUP_DATA_CALL.
1616 // Version 4 of the RIL interface adds a new PDP type parameter to support
1617 // IPv6 and dual-stack PDP contexts. When dealing with a previous version of
1618 // RIL, remove the parameter from the request.
1619 static void dispatchDataCall(Parcel& p, RequestInfo *pRI) {
1620     // In RIL v3, REQUEST_SETUP_DATA_CALL takes 6 parameters.
1621     const int numParamsRilV3 = 6;
1622
1623     // The first bytes of the RIL parcel contain the request number and the
1624     // serial number - see processCommandBuffer(). Copy them over too.
1625     int pos = p.dataPosition();
1626
1627     int numParams = p.readInt32();
1628     if (s_callbacks.version < 4 && numParams > numParamsRilV3) {
1629       Parcel p2;
1630       p2.appendFrom(&p, 0, pos);
1631       p2.writeInt32(numParamsRilV3);
1632       for(int i = 0; i < numParamsRilV3; i++) {
1633         p2.writeString16(p.readString16());
1634       }
1635       p2.setDataPosition(pos);
1636       dispatchStrings(p2, pRI);
1637     } else {
1638       p.setDataPosition(pos);
1639       dispatchStrings(p, pRI);
1640     }
1641 }
1642
1643 // For backwards compatibility with RILs that dont support RIL_REQUEST_VOICE_RADIO_TECH.
1644 // When all RILs handle this request, this function can be removed and
1645 // the request can be sent directly to the RIL using dispatchVoid.
1646 static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) {
1647     RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id);
1648
1649     if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
1650         RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1651     }
1652
1653     // RILs that support RADIO_STATE_ON should support this request.
1654     if (RADIO_STATE_ON == state) {
1655         dispatchVoid(p, pRI);
1656         return;
1657     }
1658
1659     // For Older RILs, that do not support RADIO_STATE_ON, assume that they
1660     // will not support this new request either and decode Voice Radio Technology
1661     // from Radio State
1662     voiceRadioTech = decodeVoiceRadioTechnology(state);
1663
1664     if (voiceRadioTech < 0)
1665         RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
1666     else
1667         RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &voiceRadioTech, sizeof(int));
1668 }
1669
1670 // For backwards compatibility in RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:.
1671 // When all RILs handle this request, this function can be removed and
1672 // the request can be sent directly to the RIL using dispatchVoid.
1673 static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) {
1674     RIL_RadioState state = CALL_ONSTATEREQUEST((RIL_SOCKET_ID)pRI->socket_id);
1675
1676     if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
1677         RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1678     }
1679
1680     // RILs that support RADIO_STATE_ON should support this request.
1681     if (RADIO_STATE_ON == state) {
1682         dispatchVoid(p, pRI);
1683         return;
1684     }
1685
1686     // For Older RILs, that do not support RADIO_STATE_ON, assume that they
1687     // will not support this new request either and decode CDMA Subscription Source
1688     // from Radio State
1689     cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state);
1690
1691     if (cdmaSubscriptionSource < 0)
1692         RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
1693     else
1694         RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int));
1695 }
1696
1697 static void dispatchSetInitialAttachApn(Parcel &p, RequestInfo *pRI)
1698 {
1699     RIL_InitialAttachApn pf;
1700     int32_t  t;
1701     status_t status;
1702
1703     memset(&pf, 0, sizeof(pf));
1704
1705     pf.apn = strdupReadString(p);
1706     pf.protocol = strdupReadString(p);
1707
1708     status = p.readInt32(&t);
1709     pf.authtype = (int) t;
1710
1711     pf.username = strdupReadString(p);
1712     pf.password = strdupReadString(p);
1713
1714     startRequest;
1715     appendPrintBuf("%sapn=%s, protocol=%s, authtype=%d, username=%s, password=%s",
1716             printBuf, pf.apn, pf.protocol, pf.authtype, pf.username, pf.password);
1717     closeRequest;
1718     printRequest(pRI->token, pRI->pCI->requestNumber);
1719
1720     if (status != NO_ERROR) {
1721         goto invalid;
1722     }
1723     CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id);
1724
1725 #ifdef MEMSET_FREED
1726     memsetString(pf.apn);
1727     memsetString(pf.protocol);
1728     memsetString(pf.username);
1729     memsetString(pf.password);
1730 #endif
1731
1732     free(pf.apn);
1733     free(pf.protocol);
1734     free(pf.username);
1735     free(pf.password);
1736
1737 #ifdef MEMSET_FREED
1738     memset(&pf, 0, sizeof(pf));
1739 #endif
1740
1741     return;
1742 invalid:
1743     invalidCommandBlock(pRI);
1744     return;
1745 }
1746
1747 static void dispatchNVReadItem(Parcel &p, RequestInfo *pRI) {
1748     RIL_NV_ReadItem nvri;
1749     int32_t  t;
1750     status_t status;
1751
1752     memset(&nvri, 0, sizeof(nvri));
1753
1754     status = p.readInt32(&t);
1755     nvri.itemID = (RIL_NV_Item) t;
1756
1757     if (status != NO_ERROR) {
1758         goto invalid;
1759     }
1760
1761     startRequest;
1762     appendPrintBuf("%snvri.itemID=%d, ", printBuf, nvri.itemID);
1763     closeRequest;
1764
1765     printRequest(pRI->token, pRI->pCI->requestNumber);
1766
1767     CALL_ONREQUEST(pRI->pCI->requestNumber, &nvri, sizeof(nvri), pRI, pRI->socket_id);
1768
1769 #ifdef MEMSET_FREED
1770     memset(&nvri, 0, sizeof(nvri));
1771 #endif
1772
1773     return;
1774
1775 invalid:
1776     invalidCommandBlock(pRI);
1777     return;
1778 }
1779
1780 static void dispatchNVWriteItem(Parcel &p, RequestInfo *pRI) {
1781     RIL_NV_WriteItem nvwi;
1782     int32_t  t;
1783     status_t status;
1784
1785     memset(&nvwi, 0, sizeof(nvwi));
1786
1787     status = p.readInt32(&t);
1788     nvwi.itemID = (RIL_NV_Item) t;
1789
1790     nvwi.value = strdupReadString(p);
1791
1792     if (status != NO_ERROR || nvwi.value == NULL) {
1793         goto invalid;
1794     }
1795
1796     startRequest;
1797     appendPrintBuf("%snvwi.itemID=%d, value=%s, ", printBuf, nvwi.itemID,
1798             nvwi.value);
1799     closeRequest;
1800
1801     printRequest(pRI->token, pRI->pCI->requestNumber);
1802
1803     CALL_ONREQUEST(pRI->pCI->requestNumber, &nvwi, sizeof(nvwi), pRI, pRI->socket_id);
1804
1805 #ifdef MEMSET_FREED
1806     memsetString(nvwi.value);
1807 #endif
1808
1809     free(nvwi.value);
1810
1811 #ifdef MEMSET_FREED
1812     memset(&nvwi, 0, sizeof(nvwi));
1813 #endif
1814
1815     return;
1816
1817 invalid:
1818     invalidCommandBlock(pRI);
1819     return;
1820 }
1821
1822
1823 static void dispatchUiccSubscripton(Parcel &p, RequestInfo *pRI) {
1824     RIL_SelectUiccSub uicc_sub;
1825     status_t status;
1826     int32_t  t;
1827     memset(&uicc_sub, 0, sizeof(uicc_sub));
1828
1829     status = p.readInt32(&t);
1830     if (status != NO_ERROR) {
1831         goto invalid;
1832     }
1833     uicc_sub.slot = (int) t;
1834
1835     status = p.readInt32(&t);
1836     if (status != NO_ERROR) {
1837         goto invalid;
1838     }
1839     uicc_sub.app_index = (int) t;
1840
1841     status = p.readInt32(&t);
1842     if (status != NO_ERROR) {
1843         goto invalid;
1844     }
1845     uicc_sub.sub_type = (RIL_SubscriptionType) t;
1846
1847     status = p.readInt32(&t);
1848     if (status != NO_ERROR) {
1849         goto invalid;
1850     }
1851     uicc_sub.act_status = (RIL_UiccSubActStatus) t;
1852
1853     startRequest;
1854     appendPrintBuf("slot=%d, app_index=%d, act_status = %d", uicc_sub.slot, uicc_sub.app_index,
1855             uicc_sub.act_status);
1856     RLOGD("dispatchUiccSubscription, slot=%d, app_index=%d, act_status = %d", uicc_sub.slot,
1857             uicc_sub.app_index, uicc_sub.act_status);
1858     closeRequest;
1859     printRequest(pRI->token, pRI->pCI->requestNumber);
1860
1861     CALL_ONREQUEST(pRI->pCI->requestNumber, &uicc_sub, sizeof(uicc_sub), pRI, pRI->socket_id);
1862
1863 #ifdef MEMSET_FREED
1864     memset(&uicc_sub, 0, sizeof(uicc_sub));
1865 #endif
1866     return;
1867
1868 invalid:
1869     invalidCommandBlock(pRI);
1870     return;
1871 }
1872
1873 static void dispatchSimAuthentication(Parcel &p, RequestInfo *pRI)
1874 {
1875     RIL_SimAuthentication pf;
1876     int32_t  t;
1877     status_t status;
1878
1879     memset(&pf, 0, sizeof(pf));
1880
1881     status = p.readInt32(&t);
1882     pf.authContext = (int) t;
1883     pf.authData = strdupReadString(p);
1884     pf.aid = strdupReadString(p);
1885
1886     startRequest;
1887     appendPrintBuf("authContext=%s, authData=%s, aid=%s", pf.authContext, pf.authData, pf.aid);
1888     closeRequest;
1889     printRequest(pRI->token, pRI->pCI->requestNumber);
1890
1891     if (status != NO_ERROR) {
1892         goto invalid;
1893     }
1894     CALL_ONREQUEST(pRI->pCI->requestNumber, &pf, sizeof(pf), pRI, pRI->socket_id);
1895
1896 #ifdef MEMSET_FREED
1897     memsetString(pf.authData);
1898     memsetString(pf.aid);
1899 #endif
1900
1901     free(pf.authData);
1902     free(pf.aid);
1903
1904 #ifdef MEMSET_FREED
1905     memset(&pf, 0, sizeof(pf));
1906 #endif
1907
1908     return;
1909 invalid:
1910     invalidCommandBlock(pRI);
1911     return;
1912 }
1913
1914 static void dispatchDataProfile(Parcel &p, RequestInfo *pRI) {
1915     int32_t t;
1916     status_t status;
1917     int32_t num;
1918
1919     status = p.readInt32(&num);
1920     if (status != NO_ERROR) {
1921         goto invalid;
1922     }
1923
1924     {
1925         RIL_DataProfileInfo dataProfiles[num];
1926         RIL_DataProfileInfo *dataProfilePtrs[num];
1927
1928         startRequest;
1929         for (int i = 0 ; i < num ; i++ ) {
1930             dataProfilePtrs[i] = &dataProfiles[i];
1931
1932             status = p.readInt32(&t);
1933             dataProfiles[i].profileId = (int) t;
1934
1935             dataProfiles[i].apn = strdupReadString(p);
1936             dataProfiles[i].protocol = strdupReadString(p);
1937             status = p.readInt32(&t);
1938             dataProfiles[i].authType = (int) t;
1939
1940             dataProfiles[i].user = strdupReadString(p);
1941             dataProfiles[i].password = strdupReadString(p);
1942
1943             status = p.readInt32(&t);
1944             dataProfiles[i].type = (int) t;
1945
1946             status = p.readInt32(&t);
1947             dataProfiles[i].maxConnsTime = (int) t;
1948             status = p.readInt32(&t);
1949             dataProfiles[i].maxConns = (int) t;
1950             status = p.readInt32(&t);
1951             dataProfiles[i].waitTime = (int) t;
1952
1953             status = p.readInt32(&t);
1954             dataProfiles[i].enabled = (int) t;
1955
1956             appendPrintBuf("%s [%d: profileId=%d, apn =%s, protocol =%s, authType =%d, \
1957                   user =%s, password =%s, type =%d, maxConnsTime =%d, maxConns =%d, \
1958                   waitTime =%d, enabled =%d]", printBuf, i, dataProfiles[i].profileId,
1959                   dataProfiles[i].apn, dataProfiles[i].protocol, dataProfiles[i].authType,
1960                   dataProfiles[i].user, dataProfiles[i].password, dataProfiles[i].type,
1961                   dataProfiles[i].maxConnsTime, dataProfiles[i].maxConns,
1962                   dataProfiles[i].waitTime, dataProfiles[i].enabled);
1963         }
1964         closeRequest;
1965         printRequest(pRI->token, pRI->pCI->requestNumber);
1966
1967         if (status != NO_ERROR) {
1968             goto invalid;
1969         }
1970         CALL_ONREQUEST(pRI->pCI->requestNumber,
1971                               dataProfilePtrs,
1972                               num * sizeof(RIL_DataProfileInfo *),
1973                               pRI, pRI->socket_id);
1974
1975 #ifdef MEMSET_FREED
1976         memset(dataProfiles, 0, num * sizeof(RIL_DataProfileInfo));
1977         memset(dataProfilePtrs, 0, num * sizeof(RIL_DataProfileInfo *));
1978 #endif
1979     }
1980
1981     return;
1982
1983 invalid:
1984     invalidCommandBlock(pRI);
1985     return;
1986 }
1987
1988 static void dispatchRadioCapability(Parcel &p, RequestInfo *pRI){
1989     RIL_RadioCapability rc;
1990     int32_t t;
1991     status_t status;
1992
1993     memset (&rc, 0, sizeof(RIL_RadioCapability));
1994
1995     status = p.readInt32(&t);
1996     rc.version = (int)t;
1997     if (status != NO_ERROR) {
1998         goto invalid;
1999     }
2000
2001     status = p.readInt32(&t);
2002     rc.session= (int)t;
2003     if (status != NO_ERROR) {
2004         goto invalid;
2005     }
2006
2007     status = p.readInt32(&t);
2008     rc.phase= (int)t;
2009     if (status != NO_ERROR) {
2010         goto invalid;
2011     }
2012
2013     status = p.readInt32(&t);
2014     rc.rat = (int)t;
2015     if (status != NO_ERROR) {
2016         goto invalid;
2017     }
2018
2019     status = readStringFromParcelInplace(p, rc.logicalModemUuid, sizeof(rc.logicalModemUuid));
2020     if (status != NO_ERROR) {
2021         goto invalid;
2022     }
2023
2024     status = p.readInt32(&t);
2025     rc.status = (int)t;
2026
2027     if (status != NO_ERROR) {
2028         goto invalid;
2029     }
2030
2031     startRequest;
2032     appendPrintBuf("%s [version:%d, session:%d, phase:%d, rat:%d, \
2033             logicalModemUuid:%s, status:%d", printBuf, rc.version, rc.session,
2034             rc.phase, rc.rat, rc.logicalModemUuid, rc.session);
2035
2036     closeRequest;
2037     printRequest(pRI->token, pRI->pCI->requestNumber);
2038
2039     CALL_ONREQUEST(pRI->pCI->requestNumber,
2040                 &rc,
2041                 sizeof(RIL_RadioCapability),
2042                 pRI, pRI->socket_id);
2043     return;
2044 invalid:
2045     invalidCommandBlock(pRI);
2046     return;
2047 }
2048
2049 static int
2050 blockingWrite(int fd, const void *buffer, size_t len) {
2051     size_t writeOffset = 0;
2052     const uint8_t *toWrite;
2053
2054     toWrite = (const uint8_t *)buffer;
2055
2056     while (writeOffset < len) {
2057         ssize_t written;
2058         do {
2059             written = write (fd, toWrite + writeOffset,
2060                                 len - writeOffset);
2061         } while (written < 0 && ((errno == EINTR) || (errno == EAGAIN)));
2062
2063         if (written >= 0) {
2064             writeOffset += written;
2065         } else {   // written < 0
2066             RLOGE ("RIL Response: unexpected error on write errno:%d", errno);
2067             close(fd);
2068             return -1;
2069         }
2070     }
2071 #if VDBG
2072     RLOGE("RIL Response bytes written:%d", writeOffset);
2073 #endif
2074     return 0;
2075 }
2076
2077 static int
2078 sendResponseRaw (const void *data, size_t dataSize, RIL_SOCKET_ID socket_id) {
2079     int fd = s_ril_param_socket.fdCommand;
2080     int ret;
2081     uint32_t header;
2082     pthread_mutex_t * writeMutexHook = &s_writeMutex;
2083
2084 #if VDBG
2085     RLOGE("Send Response to %s", rilSocketIdToString(socket_id));
2086 #endif
2087
2088 #if (SIM_COUNT >= 2)
2089     if (socket_id == RIL_SOCKET_2) {
2090         fd = s_ril_param_socket2.fdCommand;
2091         writeMutexHook = &s_writeMutex_socket2;
2092     }
2093 #if (SIM_COUNT >= 3)
2094     else if (socket_id == RIL_SOCKET_3) {
2095         fd = s_ril_param_socket3.fdCommand;
2096         writeMutexHook = &s_writeMutex_socket3;
2097     }
2098 #endif
2099 #if (SIM_COUNT >= 4)
2100     else if (socket_id == RIL_SOCKET_4) {
2101         fd = s_ril_param_socket4.fdCommand;
2102         writeMutexHook = &s_writeMutex_socket4;
2103     }
2104 #endif
2105 #endif
2106     if (fd < 0) {
2107         return -1;
2108     }
2109
2110     if (dataSize > MAX_COMMAND_BYTES) {
2111         RLOGE("RIL: packet larger than %u (%u)",
2112                 MAX_COMMAND_BYTES, (unsigned int )dataSize);
2113
2114         return -1;
2115     }
2116
2117     pthread_mutex_lock(writeMutexHook);
2118
2119     header = htonl(dataSize);
2120
2121     ret = blockingWrite(fd, (void *)&header, sizeof(header));
2122
2123     if (ret < 0) {
2124         pthread_mutex_unlock(writeMutexHook);
2125         return ret;
2126     }
2127
2128     ret = blockingWrite(fd, data, dataSize);
2129
2130     if (ret < 0) {
2131         pthread_mutex_unlock(writeMutexHook);
2132         return ret;
2133     }
2134
2135     pthread_mutex_unlock(writeMutexHook);
2136
2137     return 0;
2138 }
2139
2140 static int
2141 sendResponse (Parcel &p, RIL_SOCKET_ID socket_id) {
2142     printResponse;
2143     return sendResponseRaw(p.data(), p.dataSize(), socket_id);
2144 }
2145
2146 /** response is an int* pointing to an array of ints */
2147
2148 static int
2149 responseInts(Parcel &p, void *response, size_t responselen) {
2150     int numInts;
2151
2152     if (response == NULL && responselen != 0) {
2153         RLOGE("invalid response: NULL");
2154         return RIL_ERRNO_INVALID_RESPONSE;
2155     }
2156     if (responselen % sizeof(int) != 0) {
2157         RLOGE("responseInts: invalid response length %d expected multiple of %d\n",
2158             (int)responselen, (int)sizeof(int));
2159         return RIL_ERRNO_INVALID_RESPONSE;
2160     }
2161
2162     int *p_int = (int *) response;
2163
2164     numInts = responselen / sizeof(int);
2165     p.writeInt32 (numInts);
2166
2167     /* each int*/
2168     startResponse;
2169     for (int i = 0 ; i < numInts ; i++) {
2170         appendPrintBuf("%s%d,", printBuf, p_int[i]);
2171         p.writeInt32(p_int[i]);
2172     }
2173     removeLastChar;
2174     closeResponse;
2175
2176     return 0;
2177 }
2178
2179 // Response is an int or RIL_LastCallFailCauseInfo.
2180 // Currently, only Shamu plans to use RIL_LastCallFailCauseInfo.
2181 // TODO(yjl): Let all implementations use RIL_LastCallFailCauseInfo.
2182 static int responseFailCause(Parcel &p, void *response, size_t responselen) {
2183     if (response == NULL && responselen != 0) {
2184         RLOGE("invalid response: NULL");
2185         return RIL_ERRNO_INVALID_RESPONSE;
2186     }
2187
2188     if (responselen == sizeof(int)) {
2189       startResponse;
2190       int *p_int = (int *) response;
2191       appendPrintBuf("%s%d,", printBuf, p_int[0]);
2192       p.writeInt32(p_int[0]);
2193       removeLastChar;
2194       closeResponse;
2195     } else if (responselen == sizeof(RIL_LastCallFailCauseInfo)) {
2196       startResponse;
2197       RIL_LastCallFailCauseInfo *p_fail_cause_info = (RIL_LastCallFailCauseInfo *) response;
2198       appendPrintBuf("%s[cause_code=%d,vendor_cause=%s]", printBuf, p_fail_cause_info->cause_code,
2199                      p_fail_cause_info->vendor_cause);
2200       p.writeInt32(p_fail_cause_info->cause_code);
2201       writeStringToParcel(p, p_fail_cause_info->vendor_cause);
2202       removeLastChar;
2203       closeResponse;
2204     } else {
2205       RLOGE("responseFailCause: invalid response length %d expected an int or "
2206             "RIL_LastCallFailCauseInfo", (int)responselen);
2207       return RIL_ERRNO_INVALID_RESPONSE;
2208     }
2209
2210     return 0;
2211 }
2212
2213 /** response is a char **, pointing to an array of char *'s
2214     The parcel will begin with the version */
2215 static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) {
2216     p.writeInt32(version);
2217     return responseStrings(p, response, responselen);
2218 }
2219
2220 /** response is a char **, pointing to an array of char *'s */
2221 static int responseStrings(Parcel &p, void *response, size_t responselen) {
2222     int numStrings;
2223
2224     if (response == NULL && responselen != 0) {
2225         RLOGE("invalid response: NULL");
2226         return RIL_ERRNO_INVALID_RESPONSE;
2227     }
2228     if (responselen % sizeof(char *) != 0) {
2229         RLOGE("responseStrings: invalid response length %d expected multiple of %d\n",
2230             (int)responselen, (int)sizeof(char *));
2231         return RIL_ERRNO_INVALID_RESPONSE;
2232     }
2233
2234     if (response == NULL) {
2235         p.writeInt32 (0);
2236     } else {
2237         char **p_cur = (char **) response;
2238
2239         numStrings = responselen / sizeof(char *);
2240         p.writeInt32 (numStrings);
2241
2242         /* each string*/
2243         startResponse;
2244         for (int i = 0 ; i < numStrings ; i++) {
2245             appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
2246             writeStringToParcel (p, p_cur[i]);
2247         }
2248         removeLastChar;
2249         closeResponse;
2250     }
2251     return 0;
2252 }
2253
2254
2255 /**
2256  * NULL strings are accepted
2257  * FIXME currently ignores responselen
2258  */
2259 static int responseString(Parcel &p, void *response, size_t responselen) {
2260     /* one string only */
2261     startResponse;
2262     appendPrintBuf("%s%s", printBuf, (char*)response);
2263     closeResponse;
2264
2265     writeStringToParcel(p, (const char *)response);
2266
2267     return 0;
2268 }
2269
2270 static int responseVoid(Parcel &p, void *response, size_t responselen) {
2271     startResponse;
2272     removeLastChar;
2273     return 0;
2274 }
2275
2276 static int responseCallList(Parcel &p, void *response, size_t responselen) {
2277     int num;
2278
2279     if (response == NULL && responselen != 0) {
2280         RLOGE("invalid response: NULL");
2281         return RIL_ERRNO_INVALID_RESPONSE;
2282     }
2283
2284     if (responselen % sizeof (RIL_Call *) != 0) {
2285         RLOGE("responseCallList: invalid response length %d expected multiple of %d\n",
2286             (int)responselen, (int)sizeof (RIL_Call *));
2287         return RIL_ERRNO_INVALID_RESPONSE;
2288     }
2289
2290     startResponse;
2291     /* number of call info's */
2292     num = responselen / sizeof(RIL_Call *);
2293     p.writeInt32(num);
2294
2295     for (int i = 0 ; i < num ; i++) {
2296         RIL_Call *p_cur = ((RIL_Call **) response)[i];
2297         /* each call info */
2298         p.writeInt32(p_cur->state);
2299         p.writeInt32(p_cur->index);
2300         p.writeInt32(p_cur->toa);
2301         p.writeInt32(p_cur->isMpty);
2302         p.writeInt32(p_cur->isMT);
2303         p.writeInt32(p_cur->als);
2304         p.writeInt32(p_cur->isVoice);
2305         p.writeInt32(p_cur->isVoicePrivacy);
2306         writeStringToParcel(p, p_cur->number);
2307         p.writeInt32(p_cur->numberPresentation);
2308         writeStringToParcel(p, p_cur->name);
2309         p.writeInt32(p_cur->namePresentation);
2310         // Remove when partners upgrade to version 3
2311         if ((s_callbacks.version < 3) || (p_cur->uusInfo == NULL || p_cur->uusInfo->uusData == NULL)) {
2312             p.writeInt32(0); /* UUS Information is absent */
2313         } else {
2314             RIL_UUS_Info *uusInfo = p_cur->uusInfo;
2315             p.writeInt32(1); /* UUS Information is present */
2316             p.writeInt32(uusInfo->uusType);
2317             p.writeInt32(uusInfo->uusDcs);
2318             p.writeInt32(uusInfo->uusLength);
2319             p.write(uusInfo->uusData, uusInfo->uusLength);
2320         }
2321         appendPrintBuf("%s[id=%d,%s,toa=%d,",
2322             printBuf,
2323             p_cur->index,
2324             callStateToString(p_cur->state),
2325             p_cur->toa);
2326         appendPrintBuf("%s%s,%s,als=%d,%s,%s,",
2327             printBuf,
2328             (p_cur->isMpty)?"conf":"norm",
2329             (p_cur->isMT)?"mt":"mo",
2330             p_cur->als,
2331             (p_cur->isVoice)?"voc":"nonvoc",
2332             (p_cur->isVoicePrivacy)?"evp":"noevp");
2333         appendPrintBuf("%s%s,cli=%d,name='%s',%d]",
2334             printBuf,
2335             p_cur->number,
2336             p_cur->numberPresentation,
2337             p_cur->name,
2338             p_cur->namePresentation);
2339     }
2340     removeLastChar;
2341     closeResponse;
2342
2343     return 0;
2344 }
2345
2346 static int responseSMS(Parcel &p, void *response, size_t responselen) {
2347     if (response == NULL) {
2348         RLOGE("invalid response: NULL");
2349         return RIL_ERRNO_INVALID_RESPONSE;
2350     }
2351
2352     if (responselen != sizeof (RIL_SMS_Response) ) {
2353         RLOGE("invalid response length %d expected %d",
2354                 (int)responselen, (int)sizeof (RIL_SMS_Response));
2355         return RIL_ERRNO_INVALID_RESPONSE;
2356     }
2357
2358     RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response;
2359
2360     p.writeInt32(p_cur->messageRef);
2361     writeStringToParcel(p, p_cur->ackPDU);
2362     p.writeInt32(p_cur->errorCode);
2363
2364     startResponse;
2365     appendPrintBuf("%s%d,%s,%d", printBuf, p_cur->messageRef,
2366         (char*)p_cur->ackPDU, p_cur->errorCode);
2367     closeResponse;
2368
2369     return 0;
2370 }
2371
2372 static int responseDataCallListV4(Parcel &p, void *response, size_t responselen)
2373 {
2374     if (response == NULL && responselen != 0) {
2375         RLOGE("invalid response: NULL");
2376         return RIL_ERRNO_INVALID_RESPONSE;
2377     }
2378
2379     if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) {
2380         RLOGE("responseDataCallListV4: invalid response length %d expected multiple of %d",
2381                 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v4));
2382         return RIL_ERRNO_INVALID_RESPONSE;
2383     }
2384
2385     // Write version
2386     p.writeInt32(4);
2387
2388     int num = responselen / sizeof(RIL_Data_Call_Response_v4);
2389     p.writeInt32(num);
2390
2391     RIL_Data_Call_Response_v4 *p_cur = (RIL_Data_Call_Response_v4 *) response;
2392     startResponse;
2393     int i;
2394     for (i = 0; i < num; i++) {
2395         p.writeInt32(p_cur[i].cid);
2396         p.writeInt32(p_cur[i].active);
2397         writeStringToParcel(p, p_cur[i].type);
2398         // apn is not used, so don't send.
2399         writeStringToParcel(p, p_cur[i].address);
2400         appendPrintBuf("%s[cid=%d,%s,%s,%s],", printBuf,
2401             p_cur[i].cid,
2402             (p_cur[i].active==0)?"down":"up",
2403             (char*)p_cur[i].type,
2404             (char*)p_cur[i].address);
2405     }
2406     removeLastChar;
2407     closeResponse;
2408
2409     return 0;
2410 }
2411
2412 static int responseDataCallListV6(Parcel &p, void *response, size_t responselen)
2413 {
2414     if (response == NULL && responselen != 0) {
2415         RLOGE("invalid response: NULL");
2416         return RIL_ERRNO_INVALID_RESPONSE;
2417     }
2418
2419     if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
2420         RLOGE("responseDataCallListV6: invalid response length %d expected multiple of %d",
2421                 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
2422         return RIL_ERRNO_INVALID_RESPONSE;
2423     }
2424
2425     // Write version
2426     p.writeInt32(6);
2427
2428     int num = responselen / sizeof(RIL_Data_Call_Response_v6);
2429     p.writeInt32(num);
2430
2431     RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
2432     startResponse;
2433     int i;
2434     for (i = 0; i < num; i++) {
2435         p.writeInt32((int)p_cur[i].status);
2436         p.writeInt32(p_cur[i].suggestedRetryTime);
2437         p.writeInt32(p_cur[i].cid);
2438         p.writeInt32(p_cur[i].active);
2439         writeStringToParcel(p, p_cur[i].type);
2440         writeStringToParcel(p, p_cur[i].ifname);
2441         writeStringToParcel(p, p_cur[i].addresses);
2442         writeStringToParcel(p, p_cur[i].dnses);
2443         writeStringToParcel(p, p_cur[i].gateways);
2444         appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s],", printBuf,
2445             p_cur[i].status,
2446             p_cur[i].suggestedRetryTime,
2447             p_cur[i].cid,
2448             (p_cur[i].active==0)?"down":"up",
2449             (char*)p_cur[i].type,
2450             (char*)p_cur[i].ifname,
2451             (char*)p_cur[i].addresses,
2452             (char*)p_cur[i].dnses,
2453             (char*)p_cur[i].gateways);
2454     }
2455     removeLastChar;
2456     closeResponse;
2457
2458     return 0;
2459 }
2460
2461 static int responseDataCallListV9(Parcel &p, void *response, size_t responselen)
2462 {
2463     if (response == NULL && responselen != 0) {
2464         RLOGE("invalid response: NULL");
2465         return RIL_ERRNO_INVALID_RESPONSE;
2466     }
2467
2468     if (responselen % sizeof(RIL_Data_Call_Response_v9) != 0) {
2469         RLOGE("responseDataCallListV9: invalid response length %d expected multiple of %d",
2470                 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v9));
2471         return RIL_ERRNO_INVALID_RESPONSE;
2472     }
2473
2474     // Write version
2475     p.writeInt32(10);
2476
2477     int num = responselen / sizeof(RIL_Data_Call_Response_v9);
2478     p.writeInt32(num);
2479
2480     RIL_Data_Call_Response_v9 *p_cur = (RIL_Data_Call_Response_v9 *) response;
2481     startResponse;
2482     int i;
2483     for (i = 0; i < num; i++) {
2484         p.writeInt32((int)p_cur[i].status);
2485         p.writeInt32(p_cur[i].suggestedRetryTime);
2486         p.writeInt32(p_cur[i].cid);
2487         p.writeInt32(p_cur[i].active);
2488         writeStringToParcel(p, p_cur[i].type);
2489         writeStringToParcel(p, p_cur[i].ifname);
2490         writeStringToParcel(p, p_cur[i].addresses);
2491         writeStringToParcel(p, p_cur[i].dnses);
2492         writeStringToParcel(p, p_cur[i].gateways);
2493         writeStringToParcel(p, p_cur[i].pcscf);
2494         appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s],", printBuf,
2495             p_cur[i].status,
2496             p_cur[i].suggestedRetryTime,
2497             p_cur[i].cid,
2498             (p_cur[i].active==0)?"down":"up",
2499             (char*)p_cur[i].type,
2500             (char*)p_cur[i].ifname,
2501             (char*)p_cur[i].addresses,
2502             (char*)p_cur[i].dnses,
2503             (char*)p_cur[i].gateways,
2504             (char*)p_cur[i].pcscf);
2505     }
2506     removeLastChar;
2507     closeResponse;
2508
2509     return 0;
2510 }
2511
2512 static int responseDataCallListV11(Parcel &p, void *response, size_t responselen) {
2513     if (response == NULL && responselen != 0) {
2514                 RLOGE("invalid response: NULL");
2515                 return RIL_ERRNO_INVALID_RESPONSE;
2516     }
2517
2518     if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) {
2519         RLOGE("invalid response length %d expected multiple of %d",
2520         (int)responselen, (int)sizeof(RIL_Data_Call_Response_v11));
2521         return RIL_ERRNO_INVALID_RESPONSE;
2522     }
2523
2524     // Write version
2525     p.writeInt32(11);
2526
2527     int num = responselen / sizeof(RIL_Data_Call_Response_v11);
2528     p.writeInt32(num);
2529
2530     RIL_Data_Call_Response_v11 *p_cur = (RIL_Data_Call_Response_v11 *) response;
2531     startResponse;
2532     int i;
2533     for (i = 0; i < num; i++) {
2534         p.writeInt32((int)p_cur[i].status);
2535         p.writeInt32(p_cur[i].suggestedRetryTime);
2536         p.writeInt32(p_cur[i].cid);
2537         p.writeInt32(p_cur[i].active);
2538         writeStringToParcel(p, p_cur[i].type);
2539         writeStringToParcel(p, p_cur[i].ifname);
2540         writeStringToParcel(p, p_cur[i].addresses);
2541         writeStringToParcel(p, p_cur[i].dnses);
2542         writeStringToParcel(p, p_cur[i].gateways);
2543         writeStringToParcel(p, p_cur[i].pcscf);
2544         p.writeInt32(p_cur[i].mtu);
2545         appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%s,%s,%s,%s,%s,%s,mtu=%d],", printBuf,
2546         p_cur[i].status,
2547         p_cur[i].suggestedRetryTime,
2548         p_cur[i].cid,
2549         (p_cur[i].active==0)?"down":"up",
2550         (char*)p_cur[i].type,
2551         (char*)p_cur[i].ifname,
2552         (char*)p_cur[i].addresses,
2553         (char*)p_cur[i].dnses,
2554         (char*)p_cur[i].gateways,
2555         (char*)p_cur[i].pcscf,
2556         p_cur[i].mtu);
2557     }
2558     removeLastChar;
2559     closeResponse;
2560
2561     return 0;
2562 }
2563
2564 static int responseDataCallList(Parcel &p, void *response, size_t responselen)
2565 {
2566     if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
2567         if (s_callbacks.version < 5) {
2568             RLOGD("responseDataCallList: v4");
2569             return responseDataCallListV4(p, response, responselen);
2570         } else if (responselen % sizeof(RIL_Data_Call_Response_v6) == 0) {
2571             return responseDataCallListV6(p, response, responselen);
2572         } else if (responselen % sizeof(RIL_Data_Call_Response_v9) == 0) {
2573             return responseDataCallListV9(p, response, responselen);
2574         } else {
2575             return responseDataCallListV11(p, response, responselen);
2576         }
2577     } else { // RIL version >= 12
2578         if (responselen % sizeof(RIL_Data_Call_Response_v11) != 0) {
2579             RLOGE("Data structure expected is RIL_Data_Call_Response_v11");
2580             if (!isDebuggable()) {
2581                 return RIL_ERRNO_INVALID_RESPONSE;
2582             } else {
2583                 assert(0);
2584             }
2585         }
2586         return responseDataCallListV11(p, response, responselen);
2587     }
2588 }
2589
2590 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen)
2591 {
2592     if (s_callbacks.version < 5) {
2593         return responseStringsWithVersion(s_callbacks.version, p, response, responselen);
2594     } else {
2595         return responseDataCallList(p, response, responselen);
2596     }
2597 }
2598
2599 static int responseRaw(Parcel &p, void *response, size_t responselen) {
2600     if (response == NULL && responselen != 0) {
2601         RLOGE("invalid response: NULL with responselen != 0");
2602         return RIL_ERRNO_INVALID_RESPONSE;
2603     }
2604
2605     // The java code reads -1 size as null byte array
2606     if (response == NULL) {
2607         p.writeInt32(-1);
2608     } else {
2609         p.writeInt32(responselen);
2610         p.write(response, responselen);
2611     }
2612
2613     return 0;
2614 }
2615
2616
2617 static int responseSIM_IO(Parcel &p, void *response, size_t responselen) {
2618     if (response == NULL) {
2619         RLOGE("invalid response: NULL");
2620         return RIL_ERRNO_INVALID_RESPONSE;
2621     }
2622
2623     if (responselen != sizeof (RIL_SIM_IO_Response) ) {
2624         RLOGE("invalid response length was %d expected %d",
2625                 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
2626         return RIL_ERRNO_INVALID_RESPONSE;
2627     }
2628
2629     RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response;
2630     p.writeInt32(p_cur->sw1);
2631     p.writeInt32(p_cur->sw2);
2632     writeStringToParcel(p, p_cur->simResponse);
2633
2634     startResponse;
2635     appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2,
2636         (char*)p_cur->simResponse);
2637     closeResponse;
2638
2639
2640     return 0;
2641 }
2642
2643 static int responseCallForwards(Parcel &p, void *response, size_t responselen) {
2644     int num;
2645
2646     if (response == NULL && responselen != 0) {
2647         RLOGE("invalid response: NULL");
2648         return RIL_ERRNO_INVALID_RESPONSE;
2649     }
2650
2651     if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
2652         RLOGE("responseCallForwards: invalid response length %d expected multiple of %d",
2653                 (int)responselen, (int)sizeof(RIL_CallForwardInfo *));
2654         return RIL_ERRNO_INVALID_RESPONSE;
2655     }
2656
2657     /* number of call info's */
2658     num = responselen / sizeof(RIL_CallForwardInfo *);
2659     p.writeInt32(num);
2660
2661     startResponse;
2662     for (int i = 0 ; i < num ; i++) {
2663         RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i];
2664
2665         p.writeInt32(p_cur->status);
2666         p.writeInt32(p_cur->reason);
2667         p.writeInt32(p_cur->serviceClass);
2668         p.writeInt32(p_cur->toa);
2669         writeStringToParcel(p, p_cur->number);
2670         p.writeInt32(p_cur->timeSeconds);
2671         appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
2672             (p_cur->status==1)?"enable":"disable",
2673             p_cur->reason, p_cur->serviceClass, p_cur->toa,
2674             (char*)p_cur->number,
2675             p_cur->timeSeconds);
2676     }
2677     removeLastChar;
2678     closeResponse;
2679
2680     return 0;
2681 }
2682
2683 static int responseSsn(Parcel &p, void *response, size_t responselen) {
2684     if (response == NULL) {
2685         RLOGE("invalid response: NULL");
2686         return RIL_ERRNO_INVALID_RESPONSE;
2687     }
2688
2689     if (responselen != sizeof(RIL_SuppSvcNotification)) {
2690         RLOGE("invalid response length was %d expected %d",
2691                 (int)responselen, (int)sizeof (RIL_SuppSvcNotification));
2692         return RIL_ERRNO_INVALID_RESPONSE;
2693     }
2694
2695     RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response;
2696     p.writeInt32(p_cur->notificationType);
2697     p.writeInt32(p_cur->code);
2698     p.writeInt32(p_cur->index);
2699     p.writeInt32(p_cur->type);
2700     writeStringToParcel(p, p_cur->number);
2701
2702     startResponse;
2703     appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf,
2704         (p_cur->notificationType==0)?"mo":"mt",
2705          p_cur->code, p_cur->index, p_cur->type,
2706         (char*)p_cur->number);
2707     closeResponse;
2708
2709     return 0;
2710 }
2711
2712 static int responseCellList(Parcel &p, void *response, size_t responselen) {
2713     int num;
2714
2715     if (response == NULL && responselen != 0) {
2716         RLOGE("invalid response: NULL");
2717         return RIL_ERRNO_INVALID_RESPONSE;
2718     }
2719
2720     if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
2721         RLOGE("responseCellList: invalid response length %d expected multiple of %d\n",
2722             (int)responselen, (int)sizeof (RIL_NeighboringCell *));
2723         return RIL_ERRNO_INVALID_RESPONSE;
2724     }
2725
2726     startResponse;
2727     /* number of records */
2728     num = responselen / sizeof(RIL_NeighboringCell *);
2729     p.writeInt32(num);
2730
2731     for (int i = 0 ; i < num ; i++) {
2732         RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i];
2733
2734         p.writeInt32(p_cur->rssi);
2735         writeStringToParcel (p, p_cur->cid);
2736
2737         appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf,
2738             p_cur->cid, p_cur->rssi);
2739     }
2740     removeLastChar;
2741     closeResponse;
2742
2743     return 0;
2744 }
2745
2746 /**
2747  * Marshall the signalInfoRecord into the parcel if it exists.
2748  */
2749 static void marshallSignalInfoRecord(Parcel &p,
2750             RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) {
2751     p.writeInt32(p_signalInfoRecord.isPresent);
2752     p.writeInt32(p_signalInfoRecord.signalType);
2753     p.writeInt32(p_signalInfoRecord.alertPitch);
2754     p.writeInt32(p_signalInfoRecord.signal);
2755 }
2756
2757 static int responseCdmaInformationRecords(Parcel &p,
2758             void *response, size_t responselen) {
2759     int num;
2760     char* string8 = NULL;
2761     int buffer_lenght;
2762     RIL_CDMA_InformationRecord *infoRec;
2763
2764     if (response == NULL && responselen != 0) {
2765         RLOGE("invalid response: NULL");
2766         return RIL_ERRNO_INVALID_RESPONSE;
2767     }
2768
2769     if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
2770         RLOGE("responseCdmaInformationRecords: invalid response length %d expected multiple of %d\n",
2771             (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
2772         return RIL_ERRNO_INVALID_RESPONSE;
2773     }
2774
2775     RIL_CDMA_InformationRecords *p_cur =
2776                              (RIL_CDMA_InformationRecords *) response;
2777     num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
2778
2779     startResponse;
2780     p.writeInt32(num);
2781
2782     for (int i = 0 ; i < num ; i++) {
2783         infoRec = &p_cur->infoRec[i];
2784         p.writeInt32(infoRec->name);
2785         switch (infoRec->name) {
2786             case RIL_CDMA_DISPLAY_INFO_REC:
2787             case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC:
2788                 if (infoRec->rec.display.alpha_len >
2789                                          CDMA_ALPHA_INFO_BUFFER_LENGTH) {
2790                     RLOGE("invalid display info response length %d \
2791                           expected not more than %d\n",
2792                          (int)infoRec->rec.display.alpha_len,
2793                          CDMA_ALPHA_INFO_BUFFER_LENGTH);
2794                     return RIL_ERRNO_INVALID_RESPONSE;
2795                 }
2796                 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
2797                                                              * sizeof(char) );
2798                 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
2799                     string8[i] = infoRec->rec.display.alpha_buf[i];
2800                 }
2801                 string8[(int)infoRec->rec.display.alpha_len] = '\0';
2802                 writeStringToParcel(p, (const char*)string8);
2803                 free(string8);
2804                 string8 = NULL;
2805                 break;
2806             case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
2807             case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
2808             case RIL_CDMA_CONNECTED_NUMBER_INFO_REC:
2809                 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
2810                     RLOGE("invalid display info response length %d \
2811                           expected not more than %d\n",
2812                          (int)infoRec->rec.number.len,
2813                          CDMA_NUMBER_INFO_BUFFER_LENGTH);
2814                     return RIL_ERRNO_INVALID_RESPONSE;
2815                 }
2816                 string8 = (char*) malloc((infoRec->rec.number.len + 1)
2817                                                              * sizeof(char) );
2818                 for (int i = 0 ; i < infoRec->rec.number.len; i++) {
2819                     string8[i] = infoRec->rec.number.buf[i];
2820                 }
2821                 string8[(int)infoRec->rec.number.len] = '\0';
2822                 writeStringToParcel(p, (const char*)string8);
2823                 free(string8);
2824                 string8 = NULL;
2825                 p.writeInt32(infoRec->rec.number.number_type);
2826                 p.writeInt32(infoRec->rec.number.number_plan);
2827                 p.writeInt32(infoRec->rec.number.pi);
2828                 p.writeInt32(infoRec->rec.number.si);
2829                 break;
2830             case RIL_CDMA_SIGNAL_INFO_REC:
2831                 p.writeInt32(infoRec->rec.signal.isPresent);
2832                 p.writeInt32(infoRec->rec.signal.signalType);
2833                 p.writeInt32(infoRec->rec.signal.alertPitch);
2834                 p.writeInt32(infoRec->rec.signal.signal);
2835
2836                 appendPrintBuf("%sisPresent=%X, signalType=%X, \
2837                                 alertPitch=%X, signal=%X, ",
2838                    printBuf, (int)infoRec->rec.signal.isPresent,
2839                    (int)infoRec->rec.signal.signalType,
2840                    (int)infoRec->rec.signal.alertPitch,
2841                    (int)infoRec->rec.signal.signal);
2842                 removeLastChar;
2843                 break;
2844             case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC:
2845                 if (infoRec->rec.redir.redirectingNumber.len >
2846                                               CDMA_NUMBER_INFO_BUFFER_LENGTH) {
2847                     RLOGE("invalid display info response length %d \
2848                           expected not more than %d\n",
2849                          (int)infoRec->rec.redir.redirectingNumber.len,
2850                          CDMA_NUMBER_INFO_BUFFER_LENGTH);
2851                     return RIL_ERRNO_INVALID_RESPONSE;
2852                 }
2853                 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
2854                                           .len + 1) * sizeof(char) );
2855                 for (int i = 0;
2856                          i < infoRec->rec.redir.redirectingNumber.len;
2857                          i++) {
2858                     string8[i] = infoRec->rec.redir.redirectingNumber.buf[i];
2859                 }
2860                 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
2861                 writeStringToParcel(p, (const char*)string8);
2862                 free(string8);
2863                 string8 = NULL;
2864                 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type);
2865                 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan);
2866                 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi);
2867                 p.writeInt32(infoRec->rec.redir.redirectingNumber.si);
2868                 p.writeInt32(infoRec->rec.redir.redirectingReason);
2869                 break;
2870             case RIL_CDMA_LINE_CONTROL_INFO_REC:
2871                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded);
2872                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle);
2873                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse);
2874                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial);
2875
2876                 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \
2877                                 lineCtrlToggle=%d, lineCtrlReverse=%d, \
2878                                 lineCtrlPowerDenial=%d, ", printBuf,
2879                        (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded,
2880                        (int)infoRec->rec.lineCtrl.lineCtrlToggle,
2881                        (int)infoRec->rec.lineCtrl.lineCtrlReverse,
2882                        (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial);
2883                 removeLastChar;
2884                 break;
2885             case RIL_CDMA_T53_CLIR_INFO_REC:
2886                 p.writeInt32((int)(infoRec->rec.clir.cause));
2887
2888                 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause);
2889                 removeLastChar;
2890                 break;
2891             case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC:
2892                 p.writeInt32(infoRec->rec.audioCtrl.upLink);
2893                 p.writeInt32(infoRec->rec.audioCtrl.downLink);
2894
2895                 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf,
2896                         infoRec->rec.audioCtrl.upLink,
2897                         infoRec->rec.audioCtrl.downLink);
2898                 removeLastChar;
2899                 break;
2900             case RIL_CDMA_T53_RELEASE_INFO_REC:
2901                 // TODO(Moto): See David Krause, he has the answer:)
2902                 RLOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE");
2903                 return RIL_ERRNO_INVALID_RESPONSE;
2904             default:
2905                 RLOGE("Incorrect name value");
2906                 return RIL_ERRNO_INVALID_RESPONSE;
2907         }
2908     }
2909     closeResponse;
2910
2911     return 0;
2912 }
2913
2914 static void responseRilSignalStrengthV5(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
2915     p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
2916     p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
2917     p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
2918     p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
2919     p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
2920     p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
2921     p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
2922 }
2923
2924 static void responseRilSignalStrengthV6Extra(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
2925     /*
2926      * Fixup LTE for backwards compatibility
2927      */
2928     // signalStrength: -1 -> 99
2929     if (p_cur->LTE_SignalStrength.signalStrength == -1) {
2930         p_cur->LTE_SignalStrength.signalStrength = 99;
2931     }
2932     // rsrp: -1 -> INT_MAX all other negative value to positive.
2933     // So remap here
2934     if (p_cur->LTE_SignalStrength.rsrp == -1) {
2935         p_cur->LTE_SignalStrength.rsrp = INT_MAX;
2936     } else if (p_cur->LTE_SignalStrength.rsrp < -1) {
2937         p_cur->LTE_SignalStrength.rsrp = -p_cur->LTE_SignalStrength.rsrp;
2938     }
2939     // rsrq: -1 -> INT_MAX
2940     if (p_cur->LTE_SignalStrength.rsrq == -1) {
2941         p_cur->LTE_SignalStrength.rsrq = INT_MAX;
2942     }
2943     // Not remapping rssnr is already using INT_MAX
2944
2945     // cqi: -1 -> INT_MAX
2946     if (p_cur->LTE_SignalStrength.cqi == -1) {
2947         p_cur->LTE_SignalStrength.cqi = INT_MAX;
2948     }
2949
2950     p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
2951     p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
2952     p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
2953     p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
2954     p.writeInt32(p_cur->LTE_SignalStrength.cqi);
2955 }
2956
2957 static void responseRilSignalStrengthV10(Parcel &p, RIL_SignalStrength_v10 *p_cur) {
2958     responseRilSignalStrengthV5(p, p_cur);
2959     responseRilSignalStrengthV6Extra(p, p_cur);
2960     p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp);
2961 }
2962
2963 static int responseRilSignalStrength(Parcel &p,
2964                     void *response, size_t responselen) {
2965     if (response == NULL && responselen != 0) {
2966         RLOGE("invalid response: NULL");
2967         return RIL_ERRNO_INVALID_RESPONSE;
2968     }
2969
2970     if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
2971         if (responselen >= sizeof (RIL_SignalStrength_v5)) {
2972             RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response);
2973
2974             responseRilSignalStrengthV5(p, p_cur);
2975
2976             if (responselen >= sizeof (RIL_SignalStrength_v6)) {
2977                 responseRilSignalStrengthV6Extra(p, p_cur);
2978                 if (responselen >= sizeof (RIL_SignalStrength_v10)) {
2979                     p.writeInt32(p_cur->TD_SCDMA_SignalStrength.rscp);
2980                 } else {
2981                     p.writeInt32(INT_MAX);
2982                 }
2983             } else {
2984                 p.writeInt32(99);
2985                 p.writeInt32(INT_MAX);
2986                 p.writeInt32(INT_MAX);
2987                 p.writeInt32(INT_MAX);
2988                 p.writeInt32(INT_MAX);
2989                 p.writeInt32(INT_MAX);
2990             }
2991         } else {
2992             RLOGE("invalid response length");
2993             return RIL_ERRNO_INVALID_RESPONSE;
2994         }
2995     } else { // RIL version >= 12
2996         if (responselen % sizeof(RIL_SignalStrength_v10) != 0) {
2997             RLOGE("Data structure expected is RIL_SignalStrength_v10");
2998             if (!isDebuggable()) {
2999                 return RIL_ERRNO_INVALID_RESPONSE;
3000             } else {
3001                 assert(0);
3002             }
3003         }
3004         RIL_SignalStrength_v10 *p_cur = ((RIL_SignalStrength_v10 *) response);
3005         responseRilSignalStrengthV10(p, p_cur);
3006     }
3007     startResponse;
3008     appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
3009             CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
3010             EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
3011             EVDO_SS.signalNoiseRatio=%d,\
3012             LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
3013             LTE_SS.rssnr=%d,LTE_SS.cqi=%d,TDSCDMA_SS.rscp=%d]",
3014             printBuf,
3015             p_cur->GW_SignalStrength.signalStrength,
3016             p_cur->GW_SignalStrength.bitErrorRate,
3017             p_cur->CDMA_SignalStrength.dbm,
3018             p_cur->CDMA_SignalStrength.ecio,
3019             p_cur->EVDO_SignalStrength.dbm,
3020             p_cur->EVDO_SignalStrength.ecio,
3021             p_cur->EVDO_SignalStrength.signalNoiseRatio,
3022             p_cur->LTE_SignalStrength.signalStrength,
3023             p_cur->LTE_SignalStrength.rsrp,
3024             p_cur->LTE_SignalStrength.rsrq,
3025             p_cur->LTE_SignalStrength.rssnr,
3026             p_cur->LTE_SignalStrength.cqi,
3027             p_cur->TD_SCDMA_SignalStrength.rscp);
3028     closeResponse;
3029     return 0;
3030 }
3031
3032 static int responseCallRing(Parcel &p, void *response, size_t responselen) {
3033     if ((response == NULL) || (responselen == 0)) {
3034         return responseVoid(p, response, responselen);
3035     } else {
3036         return responseCdmaSignalInfoRecord(p, response, responselen);
3037     }
3038 }
3039
3040 static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) {
3041     if (response == NULL || responselen == 0) {
3042         RLOGE("invalid response: NULL");
3043         return RIL_ERRNO_INVALID_RESPONSE;
3044     }
3045
3046     if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) {
3047         RLOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n",
3048             (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord));
3049         return RIL_ERRNO_INVALID_RESPONSE;
3050     }
3051
3052     startResponse;
3053
3054     RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response);
3055     marshallSignalInfoRecord(p, *p_cur);
3056
3057     appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\
3058               signal=%d]",
3059               printBuf,
3060               p_cur->isPresent,
3061               p_cur->signalType,
3062               p_cur->alertPitch,
3063               p_cur->signal);
3064
3065     closeResponse;
3066     return 0;
3067 }
3068
3069 static int responseCdmaCallWaiting(Parcel &p, void *response,
3070             size_t responselen) {
3071     if (response == NULL && responselen != 0) {
3072         RLOGE("invalid response: NULL");
3073         return RIL_ERRNO_INVALID_RESPONSE;
3074     }
3075
3076     if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) {
3077         RLOGW("Upgrade to ril version %d\n", RIL_VERSION);
3078     }
3079
3080     RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response);
3081
3082     writeStringToParcel(p, p_cur->number);
3083     p.writeInt32(p_cur->numberPresentation);
3084     writeStringToParcel(p, p_cur->name);
3085     marshallSignalInfoRecord(p, p_cur->signalInfoRecord);
3086
3087     if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
3088         if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
3089             p.writeInt32(p_cur->number_type);
3090             p.writeInt32(p_cur->number_plan);
3091         } else {
3092             p.writeInt32(0);
3093             p.writeInt32(0);
3094         }
3095     } else { // RIL version >= 12
3096         if (responselen % sizeof(RIL_CDMA_CallWaiting_v6) != 0) {
3097             RLOGE("Data structure expected is RIL_CDMA_CallWaiting_v6");
3098             if (!isDebuggable()) {
3099                 return RIL_ERRNO_INVALID_RESPONSE;
3100             } else {
3101                 assert(0);
3102             }
3103         }
3104         p.writeInt32(p_cur->number_type);
3105         p.writeInt32(p_cur->number_plan);
3106     }
3107
3108     startResponse;
3109     appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\
3110             signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\
3111             signal=%d,number_type=%d,number_plan=%d]",
3112             printBuf,
3113             p_cur->number,
3114             p_cur->numberPresentation,
3115             p_cur->name,
3116             p_cur->signalInfoRecord.isPresent,
3117             p_cur->signalInfoRecord.signalType,
3118             p_cur->signalInfoRecord.alertPitch,
3119             p_cur->signalInfoRecord.signal,
3120             p_cur->number_type,
3121             p_cur->number_plan);
3122     closeResponse;
3123
3124     return 0;
3125 }
3126
3127 static void responseSimRefreshV7(Parcel &p, void *response) {
3128       RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response);
3129       p.writeInt32(p_cur->result);
3130       p.writeInt32(p_cur->ef_id);
3131       writeStringToParcel(p, p_cur->aid);
3132
3133       appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s",
3134             printBuf,
3135             p_cur->result,
3136             p_cur->ef_id,
3137             p_cur->aid);
3138
3139 }
3140
3141 static int responseSimRefresh(Parcel &p, void *response, size_t responselen) {
3142     if (response == NULL && responselen != 0) {
3143         RLOGE("responseSimRefresh: invalid response: NULL");
3144         return RIL_ERRNO_INVALID_RESPONSE;
3145     }
3146
3147     startResponse;
3148     if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
3149         if (s_callbacks.version == 7) {
3150             responseSimRefreshV7(p, response);
3151         } else {
3152             int *p_cur = ((int *) response);
3153             p.writeInt32(p_cur[0]);
3154             p.writeInt32(p_cur[1]);
3155             writeStringToParcel(p, NULL);
3156
3157             appendPrintBuf("%sresult=%d, ef_id=%d",
3158                     printBuf,
3159                     p_cur[0],
3160                     p_cur[1]);
3161         }
3162     } else { // RIL version >= 12
3163         if (responselen % sizeof(RIL_SimRefreshResponse_v7) != 0) {
3164             RLOGE("Data structure expected is RIL_SimRefreshResponse_v7");
3165             if (!isDebuggable()) {
3166                 return RIL_ERRNO_INVALID_RESPONSE;
3167             } else {
3168                 assert(0);
3169             }
3170         }
3171         responseSimRefreshV7(p, response);
3172
3173     }
3174     closeResponse;
3175
3176     return 0;
3177 }
3178
3179 static int responseCellInfoList(Parcel &p, void *response, size_t responselen)
3180 {
3181     if (response == NULL && responselen != 0) {
3182         RLOGE("invalid response: NULL");
3183         return RIL_ERRNO_INVALID_RESPONSE;
3184     }
3185
3186     if (responselen % sizeof(RIL_CellInfo) != 0) {
3187         RLOGE("responseCellInfoList: invalid response length %d expected multiple of %d",
3188                 (int)responselen, (int)sizeof(RIL_CellInfo));
3189         return RIL_ERRNO_INVALID_RESPONSE;
3190     }
3191
3192     int num = responselen / sizeof(RIL_CellInfo);
3193     p.writeInt32(num);
3194
3195     RIL_CellInfo *p_cur = (RIL_CellInfo *) response;
3196     startResponse;
3197     int i;
3198     for (i = 0; i < num; i++) {
3199         appendPrintBuf("%s[%d: type=%d,registered=%d,timeStampType=%d,timeStamp=%lld", printBuf, i,
3200             p_cur->cellInfoType, p_cur->registered, p_cur->timeStampType, p_cur->timeStamp);
3201         p.writeInt32((int)p_cur->cellInfoType);
3202         p.writeInt32(p_cur->registered);
3203         p.writeInt32(p_cur->timeStampType);
3204         p.writeInt64(p_cur->timeStamp);
3205         switch(p_cur->cellInfoType) {
3206             case RIL_CELL_INFO_TYPE_GSM: {
3207                 appendPrintBuf("%s GSM id: mcc=%d,mnc=%d,lac=%d,cid=%d,", printBuf,
3208                     p_cur->CellInfo.gsm.cellIdentityGsm.mcc,
3209                     p_cur->CellInfo.gsm.cellIdentityGsm.mnc,
3210                     p_cur->CellInfo.gsm.cellIdentityGsm.lac,
3211                     p_cur->CellInfo.gsm.cellIdentityGsm.cid);
3212                 appendPrintBuf("%s gsmSS: ss=%d,ber=%d],", printBuf,
3213                     p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength,
3214                     p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
3215
3216                 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mcc);
3217                 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.mnc);
3218                 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.lac);
3219                 p.writeInt32(p_cur->CellInfo.gsm.cellIdentityGsm.cid);
3220                 p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.signalStrength);
3221                 p.writeInt32(p_cur->CellInfo.gsm.signalStrengthGsm.bitErrorRate);
3222                 break;
3223             }
3224             case RIL_CELL_INFO_TYPE_WCDMA: {
3225                 appendPrintBuf("%s WCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,psc=%d,", printBuf,
3226                     p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc,
3227                     p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc,
3228                     p_cur->CellInfo.wcdma.cellIdentityWcdma.lac,
3229                     p_cur->CellInfo.wcdma.cellIdentityWcdma.cid,
3230                     p_cur->CellInfo.wcdma.cellIdentityWcdma.psc);
3231                 appendPrintBuf("%s wcdmaSS: ss=%d,ber=%d],", printBuf,
3232                     p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength,
3233                     p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
3234
3235                 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mcc);
3236                 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.mnc);
3237                 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.lac);
3238                 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.cid);
3239                 p.writeInt32(p_cur->CellInfo.wcdma.cellIdentityWcdma.psc);
3240                 p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.signalStrength);
3241                 p.writeInt32(p_cur->CellInfo.wcdma.signalStrengthWcdma.bitErrorRate);
3242                 break;
3243             }
3244             case RIL_CELL_INFO_TYPE_CDMA: {
3245                 appendPrintBuf("%s CDMA id: nId=%d,sId=%d,bsId=%d,long=%d,lat=%d", printBuf,
3246                     p_cur->CellInfo.cdma.cellIdentityCdma.networkId,
3247                     p_cur->CellInfo.cdma.cellIdentityCdma.systemId,
3248                     p_cur->CellInfo.cdma.cellIdentityCdma.basestationId,
3249                     p_cur->CellInfo.cdma.cellIdentityCdma.longitude,
3250                     p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
3251
3252                 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.networkId);
3253                 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.systemId);
3254                 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.basestationId);
3255                 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.longitude);
3256                 p.writeInt32(p_cur->CellInfo.cdma.cellIdentityCdma.latitude);
3257
3258                 appendPrintBuf("%s cdmaSS: dbm=%d ecio=%d evdoSS: dbm=%d,ecio=%d,snr=%d", printBuf,
3259                     p_cur->CellInfo.cdma.signalStrengthCdma.dbm,
3260                     p_cur->CellInfo.cdma.signalStrengthCdma.ecio,
3261                     p_cur->CellInfo.cdma.signalStrengthEvdo.dbm,
3262                     p_cur->CellInfo.cdma.signalStrengthEvdo.ecio,
3263                     p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
3264
3265                 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.dbm);
3266                 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthCdma.ecio);
3267                 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.dbm);
3268                 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.ecio);
3269                 p.writeInt32(p_cur->CellInfo.cdma.signalStrengthEvdo.signalNoiseRatio);
3270                 break;
3271             }
3272             case RIL_CELL_INFO_TYPE_LTE: {
3273                 appendPrintBuf("%s LTE id: mcc=%d,mnc=%d,ci=%d,pci=%d,tac=%d", printBuf,
3274                     p_cur->CellInfo.lte.cellIdentityLte.mcc,
3275                     p_cur->CellInfo.lte.cellIdentityLte.mnc,
3276                     p_cur->CellInfo.lte.cellIdentityLte.ci,
3277                     p_cur->CellInfo.lte.cellIdentityLte.pci,
3278                     p_cur->CellInfo.lte.cellIdentityLte.tac);
3279
3280                 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mcc);
3281                 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.mnc);
3282                 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.ci);
3283                 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.pci);
3284                 p.writeInt32(p_cur->CellInfo.lte.cellIdentityLte.tac);
3285
3286                 appendPrintBuf("%s lteSS: ss=%d,rsrp=%d,rsrq=%d,rssnr=%d,cqi=%d,ta=%d", printBuf,
3287                     p_cur->CellInfo.lte.signalStrengthLte.signalStrength,
3288                     p_cur->CellInfo.lte.signalStrengthLte.rsrp,
3289                     p_cur->CellInfo.lte.signalStrengthLte.rsrq,
3290                     p_cur->CellInfo.lte.signalStrengthLte.rssnr,
3291                     p_cur->CellInfo.lte.signalStrengthLte.cqi,
3292                     p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
3293                 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.signalStrength);
3294                 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrp);
3295                 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rsrq);
3296                 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.rssnr);
3297                 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.cqi);
3298                 p.writeInt32(p_cur->CellInfo.lte.signalStrengthLte.timingAdvance);
3299                 break;
3300             }
3301             case RIL_CELL_INFO_TYPE_TD_SCDMA: {
3302                 appendPrintBuf("%s TDSCDMA id: mcc=%d,mnc=%d,lac=%d,cid=%d,cpid=%d,", printBuf,
3303                     p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc,
3304                     p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc,
3305                     p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac,
3306                     p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid,
3307                     p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
3308                 appendPrintBuf("%s tdscdmaSS: rscp=%d],", printBuf,
3309                     p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
3310
3311                 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mcc);
3312                 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.mnc);
3313                 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.lac);
3314                 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cid);
3315                 p.writeInt32(p_cur->CellInfo.tdscdma.cellIdentityTdscdma.cpid);
3316                 p.writeInt32(p_cur->CellInfo.tdscdma.signalStrengthTdscdma.rscp);
3317                 break;
3318             }
3319         }
3320         p_cur += 1;
3321     }
3322     removeLastChar;
3323     closeResponse;
3324
3325     return 0;
3326 }
3327
3328 static int responseHardwareConfig(Parcel &p, void *response, size_t responselen)
3329 {
3330    if (response == NULL && responselen != 0) {
3331        RLOGE("invalid response: NULL");
3332        return RIL_ERRNO_INVALID_RESPONSE;
3333    }
3334
3335    if (responselen % sizeof(RIL_HardwareConfig) != 0) {
3336        RLOGE("responseHardwareConfig: invalid response length %d expected multiple of %d",
3337           (int)responselen, (int)sizeof(RIL_HardwareConfig));
3338        return RIL_ERRNO_INVALID_RESPONSE;
3339    }
3340
3341    int num = responselen / sizeof(RIL_HardwareConfig);
3342    int i;
3343    RIL_HardwareConfig *p_cur = (RIL_HardwareConfig *) response;
3344
3345    p.writeInt32(num);
3346
3347    startResponse;
3348    for (i = 0; i < num; i++) {
3349       switch (p_cur[i].type) {
3350          case RIL_HARDWARE_CONFIG_MODEM: {
3351             writeStringToParcel(p, p_cur[i].uuid);
3352             p.writeInt32((int)p_cur[i].state);
3353             p.writeInt32(p_cur[i].cfg.modem.rat);
3354             p.writeInt32(p_cur[i].cfg.modem.maxVoice);
3355             p.writeInt32(p_cur[i].cfg.modem.maxData);
3356             p.writeInt32(p_cur[i].cfg.modem.maxStandby);
3357
3358             appendPrintBuf("%s modem: uuid=%s,state=%d,rat=%08x,maxV=%d,maxD=%d,maxS=%d", printBuf,
3359                p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.modem.rat,
3360                p_cur[i].cfg.modem.maxVoice, p_cur[i].cfg.modem.maxData, p_cur[i].cfg.modem.maxStandby);
3361             break;
3362          }
3363          case RIL_HARDWARE_CONFIG_SIM: {
3364             writeStringToParcel(p, p_cur[i].uuid);
3365             p.writeInt32((int)p_cur[i].state);
3366             writeStringToParcel(p, p_cur[i].cfg.sim.modemUuid);
3367
3368             appendPrintBuf("%s sim: uuid=%s,state=%d,modem-uuid=%s", printBuf,
3369                p_cur[i].uuid, (int)p_cur[i].state, p_cur[i].cfg.sim.modemUuid);
3370             break;
3371          }
3372       }
3373    }
3374    removeLastChar;
3375    closeResponse;
3376    return 0;
3377 }
3378
3379 static int responseRadioCapability(Parcel &p, void *response, size_t responselen) {
3380     if (response == NULL) {
3381         RLOGE("invalid response: NULL");
3382         return RIL_ERRNO_INVALID_RESPONSE;
3383     }
3384
3385     if (responselen != sizeof (RIL_RadioCapability) ) {
3386         RLOGE("invalid response length was %d expected %d",
3387                 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
3388         return RIL_ERRNO_INVALID_RESPONSE;
3389     }
3390
3391     RIL_RadioCapability *p_cur = (RIL_RadioCapability *) response;
3392     p.writeInt32(p_cur->version);
3393     p.writeInt32(p_cur->session);
3394     p.writeInt32(p_cur->phase);
3395     p.writeInt32(p_cur->rat);
3396     writeStringToParcel(p, p_cur->logicalModemUuid);
3397     p.writeInt32(p_cur->status);
3398
3399     startResponse;
3400     appendPrintBuf("%s[version=%d,session=%d,phase=%d,\
3401             rat=%s,logicalModemUuid=%s,status=%d]",
3402             printBuf,
3403             p_cur->version,
3404             p_cur->session,
3405             p_cur->phase,
3406             p_cur->rat,
3407             p_cur->logicalModemUuid,
3408             p_cur->status);
3409     closeResponse;
3410     return 0;
3411 }
3412
3413 static int responseSSData(Parcel &p, void *response, size_t responselen) {
3414     RLOGD("In responseSSData");
3415     int num;
3416
3417     if (response == NULL && responselen != 0) {
3418         RLOGE("invalid response length was %d expected %d",
3419                 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
3420         return RIL_ERRNO_INVALID_RESPONSE;
3421     }
3422
3423     if (responselen != sizeof(RIL_StkCcUnsolSsResponse)) {
3424         RLOGE("invalid response length %d, expected %d",
3425                (int)responselen, (int)sizeof(RIL_StkCcUnsolSsResponse));
3426         return RIL_ERRNO_INVALID_RESPONSE;
3427     }
3428
3429     startResponse;
3430     RIL_StkCcUnsolSsResponse *p_cur = (RIL_StkCcUnsolSsResponse *) response;
3431     p.writeInt32(p_cur->serviceType);
3432     p.writeInt32(p_cur->requestType);
3433     p.writeInt32(p_cur->teleserviceType);
3434     p.writeInt32(p_cur->serviceClass);
3435     p.writeInt32(p_cur->result);
3436
3437     if (isServiceTypeCfQuery(p_cur->serviceType, p_cur->requestType)) {
3438         RLOGD("responseSSData CF type, num of Cf elements %d", p_cur->cfData.numValidIndexes);
3439         if (p_cur->cfData.numValidIndexes > NUM_SERVICE_CLASSES) {
3440             RLOGE("numValidIndexes is greater than max value %d, "
3441                   "truncating it to max value", NUM_SERVICE_CLASSES);
3442             p_cur->cfData.numValidIndexes = NUM_SERVICE_CLASSES;
3443         }
3444         /* number of call info's */
3445         p.writeInt32(p_cur->cfData.numValidIndexes);
3446
3447         for (int i = 0; i < p_cur->cfData.numValidIndexes; i++) {
3448              RIL_CallForwardInfo cf = p_cur->cfData.cfInfo[i];
3449
3450              p.writeInt32(cf.status);
3451              p.writeInt32(cf.reason);
3452              p.writeInt32(cf.serviceClass);
3453              p.writeInt32(cf.toa);
3454              writeStringToParcel(p, cf.number);
3455              p.writeInt32(cf.timeSeconds);
3456              appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
3457                  (cf.status==1)?"enable":"disable", cf.reason, cf.serviceClass, cf.toa,
3458                   (char*)cf.number, cf.timeSeconds);
3459              RLOGD("Data: %d,reason=%d,cls=%d,toa=%d,num=%s,tout=%d],", cf.status,
3460                   cf.reason, cf.serviceClass, cf.toa, (char*)cf.number, cf.timeSeconds);
3461         }
3462     } else {
3463         p.writeInt32 (SS_INFO_MAX);
3464
3465         /* each int*/
3466         for (int i = 0; i < SS_INFO_MAX; i++) {
3467              appendPrintBuf("%s%d,", printBuf, p_cur->ssInfo[i]);
3468              RLOGD("Data: %d",p_cur->ssInfo[i]);
3469              p.writeInt32(p_cur->ssInfo[i]);
3470         }
3471     }
3472     removeLastChar;
3473     closeResponse;
3474
3475     return 0;
3476 }
3477
3478 static bool isServiceTypeCfQuery(RIL_SsServiceType serType, RIL_SsRequestType reqType) {
3479     if ((reqType == SS_INTERROGATION) &&
3480         (serType == SS_CFU ||
3481          serType == SS_CF_BUSY ||
3482          serType == SS_CF_NO_REPLY ||
3483          serType == SS_CF_NOT_REACHABLE ||
3484          serType == SS_CF_ALL ||
3485          serType == SS_CF_ALL_CONDITIONAL)) {
3486         return true;
3487     }
3488     return false;
3489 }
3490
3491 static void triggerEvLoop() {
3492     int ret;
3493     if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
3494         /* trigger event loop to wakeup. No reason to do this,
3495          * if we're in the event loop thread */
3496          do {
3497             ret = write (s_fdWakeupWrite, " ", 1);
3498          } while (ret < 0 && errno == EINTR);
3499     }
3500 }
3501
3502 static void rilEventAddWakeup(struct ril_event *ev) {
3503     ril_event_add(ev);
3504     triggerEvLoop();
3505 }
3506
3507 static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) {
3508         p.writeInt32(num_apps);
3509         startResponse;
3510         for (int i = 0; i < num_apps; i++) {
3511             p.writeInt32(appStatus[i].app_type);
3512             p.writeInt32(appStatus[i].app_state);
3513             p.writeInt32(appStatus[i].perso_substate);
3514             writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr));
3515             writeStringToParcel(p, (const char*)
3516                                           (appStatus[i].app_label_ptr));
3517             p.writeInt32(appStatus[i].pin1_replaced);
3518             p.writeInt32(appStatus[i].pin1);
3519             p.writeInt32(appStatus[i].pin2);
3520             appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\
3521                     aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],",
3522                     printBuf,
3523                     appStatus[i].app_type,
3524                     appStatus[i].app_state,
3525                     appStatus[i].perso_substate,
3526                     appStatus[i].aid_ptr,
3527                     appStatus[i].app_label_ptr,
3528                     appStatus[i].pin1_replaced,
3529                     appStatus[i].pin1,
3530                     appStatus[i].pin2);
3531         }
3532         closeResponse;
3533 }
3534
3535 static void responseSimStatusV5(Parcel &p, void *response) {
3536     RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
3537
3538     p.writeInt32(p_cur->card_state);
3539     p.writeInt32(p_cur->universal_pin_state);
3540     p.writeInt32(p_cur->gsm_umts_subscription_app_index);
3541     p.writeInt32(p_cur->cdma_subscription_app_index);
3542
3543     sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
3544 }
3545
3546 static void responseSimStatusV6(Parcel &p, void *response) {
3547     RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
3548
3549     p.writeInt32(p_cur->card_state);
3550     p.writeInt32(p_cur->universal_pin_state);
3551     p.writeInt32(p_cur->gsm_umts_subscription_app_index);
3552     p.writeInt32(p_cur->cdma_subscription_app_index);
3553     p.writeInt32(p_cur->ims_subscription_app_index);
3554
3555     sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
3556 }
3557
3558 static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
3559     int i;
3560
3561     if (response == NULL && responselen != 0) {
3562         RLOGE("invalid response: NULL");
3563         return RIL_ERRNO_INVALID_RESPONSE;
3564     }
3565
3566     if (s_callbacks.version <= LAST_IMPRECISE_RIL_VERSION) {
3567         if (responselen == sizeof (RIL_CardStatus_v6)) {
3568             responseSimStatusV6(p, response);
3569         } else if (responselen == sizeof (RIL_CardStatus_v5)) {
3570             responseSimStatusV5(p, response);
3571         } else {
3572             RLOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
3573             return RIL_ERRNO_INVALID_RESPONSE;
3574         }
3575     } else { // RIL version >= 12
3576         if (responselen % sizeof(RIL_CardStatus_v6) != 0) {
3577             RLOGE("Data structure expected is RIL_CardStatus_v6");
3578             if (!isDebuggable()) {
3579                 return RIL_ERRNO_INVALID_RESPONSE;
3580             } else {
3581                 assert(0);
3582             }
3583         }
3584         responseSimStatusV6(p, response);
3585     }
3586
3587     return 0;
3588 }
3589
3590 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) {
3591     int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
3592     p.writeInt32(num);
3593
3594     startResponse;
3595     RIL_GSM_BroadcastSmsConfigInfo **p_cur =
3596                 (RIL_GSM_BroadcastSmsConfigInfo **) response;
3597     for (int i = 0; i < num; i++) {
3598         p.writeInt32(p_cur[i]->fromServiceId);
3599         p.writeInt32(p_cur[i]->toServiceId);
3600         p.writeInt32(p_cur[i]->fromCodeScheme);
3601         p.writeInt32(p_cur[i]->toCodeScheme);
3602         p.writeInt32(p_cur[i]->selected);
3603
3604         appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \
3605                 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]",
3606                 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId,
3607                 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme,
3608                 p_cur[i]->selected);
3609     }
3610     closeResponse;
3611
3612     return 0;
3613 }
3614
3615 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) {
3616     RIL_CDMA_BroadcastSmsConfigInfo **p_cur =
3617                (RIL_CDMA_BroadcastSmsConfigInfo **) response;
3618
3619     int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *);
3620     p.writeInt32(num);
3621
3622     startResponse;
3623     for (int i = 0 ; i < num ; i++ ) {
3624         p.writeInt32(p_cur[i]->service_category);
3625         p.writeInt32(p_cur[i]->language);
3626         p.writeInt32(p_cur[i]->selected);
3627
3628         appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \
3629               selected =%d], ",
3630               printBuf, i, p_cur[i]->service_category, p_cur[i]->language,
3631               p_cur[i]->selected);
3632     }
3633     closeResponse;
3634
3635     return 0;
3636 }
3637
3638 static int responseCdmaSms(Parcel &p, void *response, size_t responselen) {
3639     int num;
3640     int digitCount;
3641     int digitLimit;
3642     uint8_t uct;
3643     void* dest;
3644
3645     RLOGD("Inside responseCdmaSms");
3646
3647     if (response == NULL && responselen != 0) {
3648         RLOGE("invalid response: NULL");
3649         return RIL_ERRNO_INVALID_RESPONSE;
3650     }
3651
3652     if (responselen != sizeof(RIL_CDMA_SMS_Message)) {
3653         RLOGE("invalid response length was %d expected %d",
3654                 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message));
3655         return RIL_ERRNO_INVALID_RESPONSE;
3656     }
3657
3658     RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response;
3659     p.writeInt32(p_cur->uTeleserviceID);
3660     p.write(&(p_cur->bIsServicePresent),sizeof(uct));
3661     p.writeInt32(p_cur->uServicecategory);
3662     p.writeInt32(p_cur->sAddress.digit_mode);
3663     p.writeInt32(p_cur->sAddress.number_mode);
3664     p.writeInt32(p_cur->sAddress.number_type);
3665     p.writeInt32(p_cur->sAddress.number_plan);
3666     p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct));
3667     digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
3668     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
3669         p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct));
3670     }
3671
3672     p.writeInt32(p_cur->sSubAddress.subaddressType);
3673     p.write(&(p_cur->sSubAddress.odd),sizeof(uct));
3674     p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct));
3675     digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
3676     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
3677         p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct));
3678     }
3679
3680     digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
3681     p.writeInt32(p_cur->uBearerDataLen);
3682     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
3683        p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct));
3684     }
3685
3686     startResponse;
3687     appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
3688             sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ",
3689             printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory,
3690             p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type);
3691     closeResponse;
3692
3693     return 0;
3694 }
3695
3696 static int responseDcRtInfo(Parcel &p, void *response, size_t responselen)
3697 {
3698     int num = responselen / sizeof(RIL_DcRtInfo);
3699     if ((responselen % sizeof(RIL_DcRtInfo) != 0) || (num != 1)) {
3700         RLOGE("responseDcRtInfo: invalid response length %d expected multiple of %d",
3701                 (int)responselen, (int)sizeof(RIL_DcRtInfo));
3702         return RIL_ERRNO_INVALID_RESPONSE;
3703     }
3704
3705     startResponse;
3706     RIL_DcRtInfo *pDcRtInfo = (RIL_DcRtInfo *)response;
3707     p.writeInt64(pDcRtInfo->time);
3708     p.writeInt32(pDcRtInfo->powerState);
3709     appendPrintBuf("%s[time=%d,powerState=%d]", printBuf,
3710         pDcRtInfo->time,
3711         pDcRtInfo->powerState);
3712     closeResponse;
3713
3714     return 0;
3715 }
3716
3717 static int responseLceStatus(Parcel &p, void *response, size_t responselen) {
3718   if (response == NULL || responselen != sizeof(RIL_LceStatusInfo)) {
3719     if (response == NULL) {
3720       RLOGE("invalid response: NULL");
3721     }
3722     else {
3723       RLOGE("responseLceStatus: invalid response length %d expecting len: d%",
3724             sizeof(RIL_LceStatusInfo), responselen);
3725     }
3726     return RIL_ERRNO_INVALID_RESPONSE;
3727   }
3728
3729   RIL_LceStatusInfo *p_cur = (RIL_LceStatusInfo *)response;
3730   p.write((void *)p_cur, 1);  // p_cur->lce_status takes one byte.
3731   p.writeInt32(p_cur->actual_interval_ms);
3732
3733   startResponse;
3734   appendPrintBuf("LCE Status: %d, actual_interval_ms: %d",
3735                  p_cur->lce_status, p_cur->actual_interval_ms);
3736   closeResponse;
3737
3738   return 0;
3739 }
3740
3741 static int responseLceData(Parcel &p, void *response, size_t responselen) {
3742   if (response == NULL || responselen != sizeof(RIL_LceDataInfo)) {
3743     if (response == NULL) {
3744       RLOGE("invalid response: NULL");
3745     }
3746     else {
3747       RLOGE("responseLceData: invalid response length %d expecting len: d%",
3748             sizeof(RIL_LceDataInfo), responselen);
3749     }
3750     return RIL_ERRNO_INVALID_RESPONSE;
3751   }
3752
3753   RIL_LceDataInfo *p_cur = (RIL_LceDataInfo *)response;
3754   p.writeInt32(p_cur->last_hop_capacity_kbps);
3755
3756   /* p_cur->confidence_level and p_cur->lce_suspended take 1 byte each.*/
3757   p.write((void *)&(p_cur->confidence_level), 1);
3758   p.write((void *)&(p_cur->lce_suspended), 1);
3759
3760   startResponse;
3761   appendPrintBuf("LCE info received: capacity %d confidence level %d
3762                   and suspended %d",
3763                   p_cur->last_hop_capacity_kbps, p_cur->confidence_level,
3764                   p_cur->lce_suspended);
3765   closeResponse;
3766
3767   return 0;
3768 }
3769
3770 static int responseActivityData(Parcel &p, void *response, size_t responselen) {
3771   if (response == NULL || responselen != sizeof(RIL_ActivityStatsInfo)) {
3772     if (response == NULL) {
3773       RLOGE("invalid response: NULL");
3774     }
3775     else {
3776       RLOGE("responseActivityData: invalid response length %d expecting len: d%",
3777             sizeof(RIL_ActivityStatsInfo), responselen);
3778     }
3779     return RIL_ERRNO_INVALID_RESPONSE;
3780   }
3781
3782   RIL_ActivityStatsInfo *p_cur = (RIL_ActivityStatsInfo *)response;
3783   p.writeInt32(p_cur->sleep_mode_time_ms);
3784   p.writeInt32(p_cur->idle_mode_time_ms);
3785   for(int i = 0; i < RIL_NUM_TX_POWER_LEVELS; i++) {
3786     p.writeInt32(p_cur->tx_mode_time_ms[i]);
3787   }
3788   p.writeInt32(p_cur->rx_mode_time_ms);
3789
3790   startResponse;
3791   appendPrintBuf("Modem activity info received: sleep_mode_time_ms %d idle_mode_time_ms %d
3792                   tx_mode_time_ms %d %d %d %d %d and rx_mode_time_ms %d",
3793                   p_cur->sleep_mode_time_ms, p_cur->idle_mode_time_ms, p_cur->tx_mode_time_ms[0],
3794                   p_cur->tx_mode_time_ms[1], p_cur->tx_mode_time_ms[2], p_cur->tx_mode_time_ms[3],
3795                   p_cur->tx_mode_time_ms[4], p_cur->rx_mode_time_ms);
3796    closeResponse;
3797
3798   return 0;
3799 }
3800
3801 /**
3802  * A write on the wakeup fd is done just to pop us out of select()
3803  * We empty the buffer here and then ril_event will reset the timers on the
3804  * way back down
3805  */
3806 static void processWakeupCallback(int fd, short flags, void *param) {
3807     char buff[16];
3808     int ret;
3809
3810     RLOGV("processWakeupCallback");
3811
3812     /* empty our wakeup socket out */
3813     do {
3814         ret = read(s_fdWakeupRead, &buff, sizeof(buff));
3815     } while (ret > 0 || (ret < 0 && errno == EINTR));
3816 }
3817
3818 static void onCommandsSocketClosed(RIL_SOCKET_ID socket_id) {
3819     int ret;
3820     RequestInfo *p_cur;
3821     /* Hook for current context
3822        pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
3823     pthread_mutex_t * pendingRequestsMutexHook = &s_pendingRequestsMutex;
3824     /* pendingRequestsHook refer to &s_pendingRequests */
3825     RequestInfo **    pendingRequestsHook = &s_pendingRequests;
3826
3827 #if (SIM_COUNT >= 2)
3828     if (socket_id == RIL_SOCKET_2) {
3829         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
3830         pendingRequestsHook = &s_pendingRequests_socket2;
3831     }
3832 #if (SIM_COUNT >= 3)
3833     else if (socket_id == RIL_SOCKET_3) {
3834         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
3835         pendingRequestsHook = &s_pendingRequests_socket3;
3836     }
3837 #endif
3838 #if (SIM_COUNT >= 4)
3839     else if (socket_id == RIL_SOCKET_4) {
3840         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
3841         pendingRequestsHook = &s_pendingRequests_socket4;
3842     }
3843 #endif
3844 #endif
3845     /* mark pending requests as "cancelled" so we dont report responses */
3846     ret = pthread_mutex_lock(pendingRequestsMutexHook);
3847     assert (ret == 0);
3848
3849     p_cur = *pendingRequestsHook;
3850
3851     for (p_cur = *pendingRequestsHook
3852             ; p_cur != NULL
3853             ; p_cur  = p_cur->p_next
3854     ) {
3855         p_cur->cancelled = 1;
3856     }
3857
3858     ret = pthread_mutex_unlock(pendingRequestsMutexHook);
3859     assert (ret == 0);
3860 }
3861
3862 static void processCommandsCallback(int fd, short flags, void *param) {
3863     RecordStream *p_rs;
3864     void *p_record;
3865     size_t recordlen;
3866     int ret;
3867     SocketListenParam *p_info = (SocketListenParam *)param;
3868
3869     assert(fd == p_info->fdCommand);
3870
3871     p_rs = p_info->p_rs;
3872
3873     for (;;) {
3874         /* loop until EAGAIN/EINTR, end of stream, or other error */
3875         ret = record_stream_get_next(p_rs, &p_record, &recordlen);
3876
3877         if (ret == 0 && p_record == NULL) {
3878             /* end-of-stream */
3879             break;
3880         } else if (ret < 0) {
3881             break;
3882         } else if (ret == 0) { /* && p_record != NULL */
3883             processCommandBuffer(p_record, recordlen, p_info->socket_id);
3884         }
3885     }
3886
3887     if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {
3888         /* fatal error or end-of-stream */
3889         if (ret != 0) {
3890             RLOGE("error on reading command socket errno:%d\n", errno);
3891         } else {
3892             RLOGW("EOS.  Closing command socket.");
3893         }
3894
3895         close(fd);
3896         p_info->fdCommand = -1;
3897
3898         ril_event_del(p_info->commands_event);
3899
3900         record_stream_free(p_rs);
3901
3902         /* start listening for new connections again */
3903         rilEventAddWakeup(&s_listen_event);
3904
3905         onCommandsSocketClosed(p_info->socket_id);
3906     }
3907 }
3908
3909
3910 static void onNewCommandConnect(RIL_SOCKET_ID socket_id) {
3911     // Inform we are connected and the ril version
3912     int rilVer = s_callbacks.version;
3913     RIL_UNSOL_RESPONSE(RIL_UNSOL_RIL_CONNECTED,
3914                                     &rilVer, sizeof(rilVer), socket_id);
3915
3916     // implicit radio state changed
3917     RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
3918                                     NULL, 0, socket_id);
3919
3920     // Send last NITZ time data, in case it was missed
3921     if (s_lastNITZTimeData != NULL) {
3922         sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize, socket_id);
3923
3924         free(s_lastNITZTimeData);
3925         s_lastNITZTimeData = NULL;
3926     }
3927
3928     // Get version string
3929     if (s_callbacks.getVersion != NULL) {
3930         const char *version;
3931         version = s_callbacks.getVersion();
3932         RLOGI("RIL Daemon version: %s\n", version);
3933
3934         property_set(PROPERTY_RIL_IMPL, version);
3935     } else {
3936         RLOGI("RIL Daemon version: unavailable\n");
3937         property_set(PROPERTY_RIL_IMPL, "unavailable");
3938     }
3939
3940 }
3941
3942 static void listenCallback (int fd, short flags, void *param) {
3943     int ret;
3944     int err;
3945     int is_phone_socket;
3946     int fdCommand = -1;
3947     char* processName;
3948     RecordStream *p_rs;
3949     MySocketListenParam* listenParam;
3950     RilSocket *sapSocket = NULL;
3951     socketClient *sClient = NULL;
3952
3953     SocketListenParam *p_info = (SocketListenParam *)param;
3954
3955     if(RIL_SAP_SOCKET == p_info->type) {
3956         listenParam = (MySocketListenParam *)param;
3957         sapSocket = listenParam->socket;
3958     }
3959
3960     struct sockaddr_un peeraddr;
3961     socklen_t socklen = sizeof (peeraddr);
3962
3963     struct ucred creds;
3964     socklen_t szCreds = sizeof(creds);
3965
3966     struct passwd *pwd = NULL;
3967
3968     if(NULL == sapSocket) {
3969         assert (*p_info->fdCommand < 0);
3970         assert (fd == *p_info->fdListen);
3971         processName = PHONE_PROCESS;
3972     } else {
3973         assert (sapSocket->commandFd < 0);
3974         assert (fd == sapSocket->listenFd);
3975         processName = BLUETOOTH_PROCESS;
3976     }
3977
3978
3979     fdCommand = accept(fd, (sockaddr *) &peeraddr, &socklen);
3980
3981     if (fdCommand < 0 ) {
3982         RLOGE("Error on accept() errno:%d", errno);
3983         /* start listening for new connections again */
3984         if(NULL == sapSocket) {
3985             rilEventAddWakeup(p_info->listen_event);
3986         } else {
3987             rilEventAddWakeup(sapSocket->getListenEvent());
3988         }
3989         return;
3990     }
3991
3992     /* check the credential of the other side and only accept socket from
3993      * phone process
3994      */
3995     errno = 0;
3996     is_phone_socket = 0;
3997
3998     err = getsockopt(fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
3999
4000     if (err == 0 && szCreds > 0) {
4001         errno = 0;
4002         pwd = getpwuid(creds.uid);
4003         if (pwd != NULL) {
4004             if (strcmp(pwd->pw_name, processName) == 0) {
4005                 is_phone_socket = 1;
4006             } else {
4007                 RLOGE("RILD can't accept socket from process %s", pwd->pw_name);
4008             }
4009         } else {
4010             RLOGE("Error on getpwuid() errno: %d", errno);
4011         }
4012     } else {
4013         RLOGD("Error on getsockopt() errno: %d", errno);
4014     }
4015
4016     if (!is_phone_socket) {
4017         RLOGE("RILD must accept socket from %s", processName);
4018
4019         close(fdCommand);
4020         fdCommand = -1;
4021
4022         if(NULL == sapSocket) {
4023             onCommandsSocketClosed(p_info->socket_id);
4024
4025             /* start listening for new connections again */
4026             rilEventAddWakeup(p_info->listen_event);
4027         } else {
4028             sapSocket->onCommandsSocketClosed();
4029
4030             /* start listening for new connections again */
4031             rilEventAddWakeup(sapSocket->getListenEvent());
4032         }
4033
4034         return;
4035     }
4036
4037     ret = fcntl(fdCommand, F_SETFL, O_NONBLOCK);
4038
4039     if (ret < 0) {
4040         RLOGE ("Error setting O_NONBLOCK errno:%d", errno);
4041     }
4042
4043     if(NULL == sapSocket) {
4044         RLOGI("libril: new connection to %s", rilSocketIdToString(p_info->socket_id));
4045
4046         p_info->fdCommand = fdCommand;
4047         p_rs = record_stream_new(p_info->fdCommand, MAX_COMMAND_BYTES);
4048         p_info->p_rs = p_rs;
4049
4050         ril_event_set (p_info->commands_event, p_info->fdCommand, 1,
4051         p_info->processCommandsCallback, p_info);
4052         rilEventAddWakeup (p_info->commands_event);
4053
4054         onNewCommandConnect(p_info->socket_id);
4055     } else {
4056         RLOGI("libril: new connection");
4057
4058         sapSocket->setCommandFd(fdCommand);
4059         p_rs = record_stream_new(sapSocket->getCommandFd(), MAX_COMMAND_BYTES);
4060         sClient = new socketClient(sapSocket,p_rs);
4061         ril_event_set (sapSocket->getCallbackEvent(), sapSocket->getCommandFd(), 1,
4062         sapSocket->getCommandCb(), sClient);
4063
4064         rilEventAddWakeup(sapSocket->getCallbackEvent());
4065         sapSocket->onNewCommandConnect();
4066     }
4067 }
4068
4069 static void freeDebugCallbackArgs(int number, char **args) {
4070     for (int i = 0; i < number; i++) {
4071         if (args[i] != NULL) {
4072             free(args[i]);
4073         }
4074     }
4075     free(args);
4076 }
4077
4078 static void debugCallback (int fd, short flags, void *param) {
4079     int acceptFD, option;
4080     struct sockaddr_un peeraddr;
4081     socklen_t socklen = sizeof (peeraddr);
4082     int data;
4083     unsigned int qxdm_data[6];
4084     const char *deactData[1] = {"1"};
4085     char *actData[1];
4086     RIL_Dial dialData;
4087     int hangupData[1] = {1};
4088     int number;
4089     char **args;
4090     RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
4091     int sim_id = 0;
4092
4093     RLOGI("debugCallback for socket %s", rilSocketIdToString(socket_id));
4094
4095     acceptFD = accept (fd,  (sockaddr *) &peeraddr, &socklen);
4096
4097     if (acceptFD < 0) {
4098         RLOGE ("error accepting on debug port: %d\n", errno);
4099         return;
4100     }
4101
4102     if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
4103         RLOGE ("error reading on socket: number of Args: \n");
4104         return;
4105     }
4106     args = (char **) malloc(sizeof(char*) * number);
4107
4108     for (int i = 0; i < number; i++) {
4109         int len;
4110         if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
4111             RLOGE ("error reading on socket: Len of Args: \n");
4112             freeDebugCallbackArgs(i, args);
4113             return;
4114         }
4115         // +1 for null-term
4116         args[i] = (char *) malloc((sizeof(char) * len) + 1);
4117         if (recv(acceptFD, args[i], sizeof(char) * len, 0)
4118             != (int)sizeof(char) * len) {
4119             RLOGE ("error reading on socket: Args[%d] \n", i);
4120             freeDebugCallbackArgs(i, args);
4121             return;
4122         }
4123         char * buf = args[i];
4124         buf[len] = 0;
4125         if ((i+1) == number) {
4126             /* The last argument should be sim id 0(SIM1)~3(SIM4) */
4127             sim_id = atoi(args[i]);
4128             switch (sim_id) {
4129                 case 0:
4130                     socket_id = RIL_SOCKET_1;
4131                     break;
4132             #if (SIM_COUNT >= 2)
4133                 case 1:
4134                     socket_id = RIL_SOCKET_2;
4135                     break;
4136             #endif
4137             #if (SIM_COUNT >= 3)
4138                 case 2:
4139                     socket_id = RIL_SOCKET_3;
4140                     break;
4141             #endif
4142             #if (SIM_COUNT >= 4)
4143                 case 3:
4144                     socket_id = RIL_SOCKET_4;
4145                     break;
4146             #endif
4147                 default:
4148                     socket_id = RIL_SOCKET_1;
4149                     break;
4150             }
4151         }
4152     }
4153
4154     switch (atoi(args[0])) {
4155         case 0:
4156             RLOGI ("Connection on debug port: issuing reset.");
4157             issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0, socket_id);
4158             break;
4159         case 1:
4160             RLOGI ("Connection on debug port: issuing radio power off.");
4161             data = 0;
4162             issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id);
4163             // Close the socket
4164             if (socket_id == RIL_SOCKET_1 && s_ril_param_socket.fdCommand > 0) {
4165                 close(s_ril_param_socket.fdCommand);
4166                 s_ril_param_socket.fdCommand = -1;
4167             }
4168         #if (SIM_COUNT == 2)
4169             else if (socket_id == RIL_SOCKET_2 && s_ril_param_socket2.fdCommand > 0) {
4170                 close(s_ril_param_socket2.fdCommand);
4171                 s_ril_param_socket2.fdCommand = -1;
4172             }
4173         #endif
4174             break;
4175         case 2:
4176             RLOGI ("Debug port: issuing unsolicited voice network change.");
4177             RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0, socket_id);
4178             break;
4179         case 3:
4180             RLOGI ("Debug port: QXDM log enable.");
4181             qxdm_data[0] = 65536;     // head.func_tag
4182             qxdm_data[1] = 16;        // head.len
4183             qxdm_data[2] = 1;         // mode: 1 for 'start logging'
4184             qxdm_data[3] = 32;        // log_file_size: 32megabytes
4185             qxdm_data[4] = 0;         // log_mask
4186             qxdm_data[5] = 8;         // log_max_fileindex
4187             issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
4188                               6 * sizeof(int), socket_id);
4189             break;
4190         case 4:
4191             RLOGI ("Debug port: QXDM log disable.");
4192             qxdm_data[0] = 65536;
4193             qxdm_data[1] = 16;
4194             qxdm_data[2] = 0;          // mode: 0 for 'stop logging'
4195             qxdm_data[3] = 32;
4196             qxdm_data[4] = 0;
4197             qxdm_data[5] = 8;
4198             issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
4199                               6 * sizeof(int), socket_id);
4200             break;
4201         case 5:
4202             RLOGI("Debug port: Radio On");
4203             data = 1;
4204             issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int), socket_id);
4205             sleep(2);
4206             // Set network selection automatic.
4207             issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0, socket_id);
4208             break;
4209         case 6:
4210             RLOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]);
4211             actData[0] = args[1];
4212             issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData,
4213                               sizeof(actData), socket_id);
4214             break;
4215         case 7:
4216             RLOGI("Debug port: Deactivate Data Call");
4217             issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
4218                               sizeof(deactData), socket_id);
4219             break;
4220         case 8:
4221             RLOGI("Debug port: Dial Call");
4222             dialData.clir = 0;
4223             dialData.address = args[1];
4224             issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData), socket_id);
4225             break;
4226         case 9:
4227             RLOGI("Debug port: Answer Call");
4228             issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0, socket_id);
4229             break;
4230         case 10:
4231             RLOGI("Debug port: End Call");
4232             issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
4233                               sizeof(hangupData), socket_id);
4234             break;
4235         default:
4236             RLOGE ("Invalid request");
4237             break;
4238     }
4239     freeDebugCallbackArgs(number, args);
4240     close(acceptFD);
4241 }
4242
4243
4244 static void userTimerCallback (int fd, short flags, void *param) {
4245     UserCallbackInfo *p_info;
4246
4247     p_info = (UserCallbackInfo *)param;
4248
4249     p_info->p_callback(p_info->userParam);
4250
4251
4252     // FIXME generalize this...there should be a cancel mechanism
4253     if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) {
4254         s_last_wake_timeout_info = NULL;
4255     }
4256
4257     free(p_info);
4258 }
4259
4260
4261 static void *
4262 eventLoop(void *param) {
4263     int ret;
4264     int filedes[2];
4265
4266     ril_event_init();
4267
4268     pthread_mutex_lock(&s_startupMutex);
4269
4270     s_started = 1;
4271     pthread_cond_broadcast(&s_startupCond);
4272
4273     pthread_mutex_unlock(&s_startupMutex);
4274
4275     ret = pipe(filedes);
4276
4277     if (ret < 0) {
4278         RLOGE("Error in pipe() errno:%d", errno);
4279         return NULL;
4280     }
4281
4282     s_fdWakeupRead = filedes[0];
4283     s_fdWakeupWrite = filedes[1];
4284
4285     fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
4286
4287     ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
4288                 processWakeupCallback, NULL);
4289
4290     rilEventAddWakeup (&s_wakeupfd_event);
4291
4292     // Only returns on error
4293     ril_event_loop();
4294     RLOGE ("error in event_loop_base errno:%d", errno);
4295     // kill self to restart on error
4296     kill(0, SIGKILL);
4297
4298     return NULL;
4299 }
4300
4301 extern "C" void
4302 RIL_startEventLoop(void) {
4303     /* spin up eventLoop thread and wait for it to get started */
4304     s_started = 0;
4305     pthread_mutex_lock(&s_startupMutex);
4306
4307     pthread_attr_t attr;
4308     pthread_attr_init(&attr);
4309     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
4310
4311     int result = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
4312     if (result != 0) {
4313         RLOGE("Failed to create dispatch thread: %s", strerror(result));
4314         goto done;
4315     }
4316
4317     while (s_started == 0) {
4318         pthread_cond_wait(&s_startupCond, &s_startupMutex);
4319     }
4320
4321 done:
4322     pthread_mutex_unlock(&s_startupMutex);
4323 }
4324
4325 // Used for testing purpose only.
4326 extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) {
4327     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
4328 }
4329
4330 static void startListen(RIL_SOCKET_ID socket_id, SocketListenParam* socket_listen_p) {
4331     int fdListen = -1;
4332     int ret;
4333     char socket_name[10];
4334
4335     memset(socket_name, 0, sizeof(char)*10);
4336
4337     switch(socket_id) {
4338         case RIL_SOCKET_1:
4339             strncpy(socket_name, RIL_getRilSocketName(), 9);
4340             break;
4341     #if (SIM_COUNT >= 2)
4342         case RIL_SOCKET_2:
4343             strncpy(socket_name, SOCKET2_NAME_RIL, 9);
4344             break;
4345     #endif
4346     #if (SIM_COUNT >= 3)
4347         case RIL_SOCKET_3:
4348             strncpy(socket_name, SOCKET3_NAME_RIL, 9);
4349             break;
4350     #endif
4351     #if (SIM_COUNT >= 4)
4352         case RIL_SOCKET_4:
4353             strncpy(socket_name, SOCKET4_NAME_RIL, 9);
4354             break;
4355     #endif
4356         default:
4357             RLOGE("Socket id is wrong!!");
4358             return;
4359     }
4360
4361     RLOGI("Start to listen %s", rilSocketIdToString(socket_id));
4362
4363     fdListen = android_get_control_socket(socket_name);
4364     if (fdListen < 0) {
4365         RLOGE("Failed to get socket %s", socket_name);
4366         exit(-1);
4367     }
4368
4369     ret = listen(fdListen, 4);
4370
4371     if (ret < 0) {
4372         RLOGE("Failed to listen on control socket '%d': %s",
4373              fdListen, strerror(errno));
4374         exit(-1);
4375     }
4376     socket_listen_p->fdListen = fdListen;
4377
4378     /* note: non-persistent so we can accept only one connection at a time */
4379     ril_event_set (socket_listen_p->listen_event, fdListen, false,
4380                 listenCallback, socket_listen_p);
4381
4382     rilEventAddWakeup (socket_listen_p->listen_event);
4383 }
4384
4385 extern "C" void
4386 RIL_register (const RIL_RadioFunctions *callbacks) {
4387     int ret;
4388     int flags;
4389
4390     RLOGI("SIM_COUNT: %d", SIM_COUNT);
4391
4392     if (callbacks == NULL) {
4393         RLOGE("RIL_register: RIL_RadioFunctions * null");
4394         return;
4395     }
4396     if (callbacks->version < RIL_VERSION_MIN) {
4397         RLOGE("RIL_register: version %d is to old, min version is %d",
4398              callbacks->version, RIL_VERSION_MIN);
4399         return;
4400     }
4401
4402     RLOGE("RIL_register: RIL version %d", callbacks->version);
4403
4404     if (s_registerCalled > 0) {
4405         RLOGE("RIL_register has been called more than once. "
4406                 "Subsequent call ignored");
4407         return;
4408     }
4409
4410     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
4411
4412     /* Initialize socket1 parameters */
4413     s_ril_param_socket = {
4414                         RIL_SOCKET_1,             /* socket_id */
4415                         -1,                       /* fdListen */
4416                         -1,                       /* fdCommand */
4417                         PHONE_PROCESS,            /* processName */
4418                         &s_commands_event,        /* commands_event */
4419                         &s_listen_event,          /* listen_event */
4420                         processCommandsCallback,  /* processCommandsCallback */
4421                         NULL                      /* p_rs */
4422                         };
4423
4424 #if (SIM_COUNT >= 2)
4425     s_ril_param_socket2 = {
4426                         RIL_SOCKET_2,               /* socket_id */
4427                         -1,                         /* fdListen */
4428                         -1,                         /* fdCommand */
4429                         PHONE_PROCESS,              /* processName */
4430                         &s_commands_event_socket2,  /* commands_event */
4431                         &s_listen_event_socket2,    /* listen_event */
4432                         processCommandsCallback,    /* processCommandsCallback */
4433                         NULL                        /* p_rs */
4434                         };
4435 #endif
4436
4437 #if (SIM_COUNT >= 3)
4438     s_ril_param_socket3 = {
4439                         RIL_SOCKET_3,               /* socket_id */
4440                         -1,                         /* fdListen */
4441                         -1,                         /* fdCommand */
4442                         PHONE_PROCESS,              /* processName */
4443                         &s_commands_event_socket3,  /* commands_event */
4444                         &s_listen_event_socket3,    /* listen_event */
4445                         processCommandsCallback,    /* processCommandsCallback */
4446                         NULL                        /* p_rs */
4447                         };
4448 #endif
4449
4450 #if (SIM_COUNT >= 4)
4451     s_ril_param_socket4 = {
4452                         RIL_SOCKET_4,               /* socket_id */
4453                         -1,                         /* fdListen */
4454                         -1,                         /* fdCommand */
4455                         PHONE_PROCESS,              /* processName */
4456                         &s_commands_event_socket4,  /* commands_event */
4457                         &s_listen_event_socket4,    /* listen_event */
4458                         processCommandsCallback,    /* processCommandsCallback */
4459                         NULL                        /* p_rs */
4460                         };
4461 #endif
4462
4463
4464     s_registerCalled = 1;
4465
4466     RLOGI("s_registerCalled flag set, %d", s_started);
4467     // Little self-check
4468
4469     for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
4470         assert(i == s_commands[i].requestNumber);
4471     }
4472
4473     for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) {
4474         assert(i + RIL_UNSOL_RESPONSE_BASE
4475                 == s_unsolResponses[i].requestNumber);
4476     }
4477
4478     // New rild impl calls RIL_startEventLoop() first
4479     // old standalone impl wants it here.
4480
4481     if (s_started == 0) {
4482         RIL_startEventLoop();
4483     }
4484
4485     // start listen socket1
4486     startListen(RIL_SOCKET_1, &s_ril_param_socket);
4487
4488 #if (SIM_COUNT >= 2)
4489     // start listen socket2
4490     startListen(RIL_SOCKET_2, &s_ril_param_socket2);
4491 #endif /* (SIM_COUNT == 2) */
4492
4493 #if (SIM_COUNT >= 3)
4494     // start listen socket3
4495     startListen(RIL_SOCKET_3, &s_ril_param_socket3);
4496 #endif /* (SIM_COUNT == 3) */
4497
4498 #if (SIM_COUNT >= 4)
4499     // start listen socket4
4500     startListen(RIL_SOCKET_4, &s_ril_param_socket4);
4501 #endif /* (SIM_COUNT == 4) */
4502
4503
4504 #if 1
4505     // start debug interface socket
4506
4507     char *inst = NULL;
4508     if (strlen(RIL_getRilSocketName()) >= strlen(SOCKET_NAME_RIL)) {
4509         inst = RIL_getRilSocketName() + strlen(SOCKET_NAME_RIL);
4510     }
4511
4512     char rildebug[MAX_DEBUG_SOCKET_NAME_LENGTH] = SOCKET_NAME_RIL_DEBUG;
4513     if (inst != NULL) {
4514         strlcat(rildebug, inst, MAX_DEBUG_SOCKET_NAME_LENGTH);
4515     }
4516
4517     s_fdDebug = android_get_control_socket(rildebug);
4518     if (s_fdDebug < 0) {
4519         RLOGE("Failed to get socket : %s errno:%d", rildebug, errno);
4520         exit(-1);
4521     }
4522
4523     ret = listen(s_fdDebug, 4);
4524
4525     if (ret < 0) {
4526         RLOGE("Failed to listen on ril debug socket '%d': %s",
4527              s_fdDebug, strerror(errno));
4528         exit(-1);
4529     }
4530
4531     ril_event_set (&s_debug_event, s_fdDebug, true,
4532                 debugCallback, NULL);
4533
4534     rilEventAddWakeup (&s_debug_event);
4535 #endif
4536
4537 }
4538
4539 extern "C" void
4540 RIL_register_socket (RIL_RadioFunctions *(*Init)(const struct RIL_Env *, int, char **),RIL_SOCKET_TYPE socketType, int argc, char **argv) {
4541
4542     RIL_RadioFunctions* UimFuncs = NULL;
4543
4544     if(Init) {
4545         UimFuncs = Init(&RilSapSocket::uimRilEnv, argc, argv);
4546
4547         switch(socketType) {
4548             case RIL_SAP_SOCKET:
4549                 RilSapSocket::initSapSocket("sap_uim_socket1", UimFuncs);
4550
4551 #if (SIM_COUNT >= 2)
4552                 RilSapSocket::initSapSocket("sap_uim_socket2", UimFuncs);
4553 #endif
4554
4555 #if (SIM_COUNT >= 3)
4556                 RilSapSocket::initSapSocket("sap_uim_socket3", UimFuncs);
4557 #endif
4558
4559 #if (SIM_COUNT >= 4)
4560                 RilSapSocket::initSapSocket("sap_uim_socket4", UimFuncs);
4561 #endif
4562         }
4563     }
4564 }
4565
4566 static int
4567 checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
4568     int ret = 0;
4569     /* Hook for current context
4570        pendingRequestsMutextHook refer to &s_pendingRequestsMutex */
4571     pthread_mutex_t* pendingRequestsMutexHook = &s_pendingRequestsMutex;
4572     /* pendingRequestsHook refer to &s_pendingRequests */
4573     RequestInfo ** pendingRequestsHook = &s_pendingRequests;
4574
4575     if (pRI == NULL) {
4576         return 0;
4577     }
4578
4579 #if (SIM_COUNT >= 2)
4580     if (pRI->socket_id == RIL_SOCKET_2) {
4581         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket2;
4582         pendingRequestsHook = &s_pendingRequests_socket2;
4583     }
4584 #if (SIM_COUNT >= 3)
4585         if (pRI->socket_id == RIL_SOCKET_3) {
4586             pendingRequestsMutexHook = &s_pendingRequestsMutex_socket3;
4587             pendingRequestsHook = &s_pendingRequests_socket3;
4588         }
4589 #endif
4590 #if (SIM_COUNT >= 4)
4591     if (pRI->socket_id == RIL_SOCKET_4) {
4592         pendingRequestsMutexHook = &s_pendingRequestsMutex_socket4;
4593         pendingRequestsHook = &s_pendingRequests_socket4;
4594     }
4595 #endif
4596 #endif
4597     pthread_mutex_lock(pendingRequestsMutexHook);
4598
4599     for(RequestInfo **ppCur = pendingRequestsHook
4600         ; *ppCur != NULL
4601         ; ppCur = &((*ppCur)->p_next)
4602     ) {
4603         if (pRI == *ppCur) {
4604             ret = 1;
4605
4606             *ppCur = (*ppCur)->p_next;
4607             break;
4608         }
4609     }
4610
4611     pthread_mutex_unlock(pendingRequestsMutexHook);
4612
4613     return ret;
4614 }
4615
4616
4617 extern "C" void
4618 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
4619     RequestInfo *pRI;
4620     int ret;
4621     int fd = s_ril_param_socket.fdCommand;
4622     size_t errorOffset;
4623     RIL_SOCKET_ID socket_id = RIL_SOCKET_1;
4624
4625     pRI = (RequestInfo *)t;
4626
4627     if (!checkAndDequeueRequestInfo(pRI)) {
4628         RLOGE ("RIL_onRequestComplete: invalid RIL_Token");
4629         return;
4630     }
4631
4632     socket_id = pRI->socket_id;
4633 #if (SIM_COUNT >= 2)
4634     if (socket_id == RIL_SOCKET_2) {
4635         fd = s_ril_param_socket2.fdCommand;
4636     }
4637 #if (SIM_COUNT >= 3)
4638         if (socket_id == RIL_SOCKET_3) {
4639             fd = s_ril_param_socket3.fdCommand;
4640         }
4641 #endif
4642 #if (SIM_COUNT >= 4)
4643     if (socket_id == RIL_SOCKET_4) {
4644         fd = s_ril_param_socket4.fdCommand;
4645     }
4646 #endif
4647 #endif
4648 #if VDBG
4649     RLOGD("RequestComplete, %s", rilSocketIdToString(socket_id));
4650 #endif
4651
4652     if (pRI->local > 0) {
4653         // Locally issued command...void only!
4654         // response does not go back up the command socket
4655         RLOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));
4656
4657         goto done;
4658     }
4659
4660     appendPrintBuf("[%04d]< %s",
4661         pRI->token, requestToString(pRI->pCI->requestNumber));
4662
4663     if (pRI->cancelled == 0) {
4664         Parcel p;
4665
4666         p.writeInt32 (RESPONSE_SOLICITED);
4667         p.writeInt32 (pRI->token);
4668         errorOffset = p.dataPosition();
4669
4670         p.writeInt32 (e);
4671
4672         if (response != NULL) {
4673             // there is a response payload, no matter success or not.
4674             ret = pRI->pCI->responseFunction(p, response, responselen);
4675
4676             /* if an error occurred, rewind and mark it */
4677             if (ret != 0) {
4678                 RLOGE ("responseFunction error, ret %d", ret);
4679                 p.setDataPosition(errorOffset);
4680                 p.writeInt32 (ret);
4681             }
4682         }
4683
4684         if (e != RIL_E_SUCCESS) {
4685             appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
4686         }
4687
4688         if (fd < 0) {
4689             RLOGD ("RIL onRequestComplete: Command channel closed");
4690         }
4691         sendResponse(p, socket_id);
4692     }
4693
4694 done:
4695     free(pRI);
4696 }
4697
4698
4699 static void
4700 grabPartialWakeLock() {
4701     acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
4702 }
4703
4704 static void
4705 releaseWakeLock() {
4706     release_wake_lock(ANDROID_WAKE_LOCK_NAME);
4707 }
4708
4709 /**
4710  * Timer callback to put us back to sleep before the default timeout
4711  */
4712 static void
4713 wakeTimeoutCallback (void *param) {
4714     // We're using "param != NULL" as a cancellation mechanism
4715     if (param == NULL) {
4716         releaseWakeLock();
4717     }
4718 }
4719
4720 static int
4721 decodeVoiceRadioTechnology (RIL_RadioState radioState) {
4722     switch (radioState) {
4723         case RADIO_STATE_SIM_NOT_READY:
4724         case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
4725         case RADIO_STATE_SIM_READY:
4726             return RADIO_TECH_UMTS;
4727
4728         case RADIO_STATE_RUIM_NOT_READY:
4729         case RADIO_STATE_RUIM_READY:
4730         case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
4731         case RADIO_STATE_NV_NOT_READY:
4732         case RADIO_STATE_NV_READY:
4733             return RADIO_TECH_1xRTT;
4734
4735         default:
4736             RLOGD("decodeVoiceRadioTechnology: Invoked with incorrect RadioState");
4737             return -1;
4738     }
4739 }
4740
4741 static int
4742 decodeCdmaSubscriptionSource (RIL_RadioState radioState) {
4743     switch (radioState) {
4744         case RADIO_STATE_SIM_NOT_READY:
4745         case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
4746         case RADIO_STATE_SIM_READY:
4747         case RADIO_STATE_RUIM_NOT_READY:
4748         case RADIO_STATE_RUIM_READY:
4749         case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
4750             return CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM;
4751
4752         case RADIO_STATE_NV_NOT_READY:
4753         case RADIO_STATE_NV_READY:
4754             return CDMA_SUBSCRIPTION_SOURCE_NV;
4755
4756         default:
4757             RLOGD("decodeCdmaSubscriptionSource: Invoked with incorrect RadioState");
4758             return -1;
4759     }
4760 }
4761
4762 static int
4763 decodeSimStatus (RIL_RadioState radioState) {
4764    switch (radioState) {
4765        case RADIO_STATE_SIM_NOT_READY:
4766        case RADIO_STATE_RUIM_NOT_READY:
4767        case RADIO_STATE_NV_NOT_READY:
4768        case RADIO_STATE_NV_READY:
4769            return -1;
4770        case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
4771        case RADIO_STATE_SIM_READY:
4772        case RADIO_STATE_RUIM_READY:
4773        case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
4774            return radioState;
4775        default:
4776            RLOGD("decodeSimStatus: Invoked with incorrect RadioState");
4777            return -1;
4778    }
4779 }
4780
4781 static bool is3gpp2(int radioTech) {
4782     switch (radioTech) {
4783         case RADIO_TECH_IS95A:
4784         case RADIO_TECH_IS95B:
4785         case RADIO_TECH_1xRTT:
4786         case RADIO_TECH_EVDO_0:
4787         case RADIO_TECH_EVDO_A:
4788         case RADIO_TECH_EVDO_B:
4789         case RADIO_TECH_EHRPD:
4790             return true;
4791         default:
4792             return false;
4793     }
4794 }
4795
4796 /* If RIL sends SIM states or RUIM states, store the voice radio
4797  * technology and subscription source information so that they can be
4798  * returned when telephony framework requests them
4799  */
4800 static RIL_RadioState
4801 processRadioState(RIL_RadioState newRadioState, RIL_SOCKET_ID socket_id) {
4802
4803     if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) {
4804         int newVoiceRadioTech;
4805         int newCdmaSubscriptionSource;
4806         int newSimStatus;
4807
4808         /* This is old RIL. Decode Subscription source and Voice Radio Technology
4809            from Radio State and send change notifications if there has been a change */
4810         newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState);
4811         if(newVoiceRadioTech != voiceRadioTech) {
4812             voiceRadioTech = newVoiceRadioTech;
4813             RIL_UNSOL_RESPONSE(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
4814                         &voiceRadioTech, sizeof(voiceRadioTech), socket_id);
4815         }
4816         if(is3gpp2(newVoiceRadioTech)) {
4817             newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState);
4818             if(newCdmaSubscriptionSource != cdmaSubscriptionSource) {
4819                 cdmaSubscriptionSource = newCdmaSubscriptionSource;
4820                 RIL_UNSOL_RESPONSE(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
4821                         &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource), socket_id);
4822             }
4823         }
4824         newSimStatus = decodeSimStatus(newRadioState);
4825         if(newSimStatus != simRuimStatus) {
4826             simRuimStatus = newSimStatus;
4827             RIL_UNSOL_RESPONSE(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0, socket_id);
4828         }
4829
4830         /* Send RADIO_ON to telephony */
4831         newRadioState = RADIO_STATE_ON;
4832     }
4833
4834     return newRadioState;
4835 }
4836
4837
4838 #if defined(ANDROID_MULTI_SIM)
4839 extern "C"
4840 void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
4841                                 size_t datalen, RIL_SOCKET_ID socket_id)
4842 #else
4843 extern "C"
4844 void RIL_onUnsolicitedResponse(int unsolResponse, const void *data,
4845                                 size_t datalen)
4846 #endif
4847 {
4848     int unsolResponseIndex;
4849     int ret;
4850     int64_t timeReceived = 0;
4851     bool shouldScheduleTimeout = false;
4852     RIL_RadioState newState;
4853     RIL_SOCKET_ID soc_id = RIL_SOCKET_1;
4854
4855 #if defined(ANDROID_MULTI_SIM)
4856     soc_id = socket_id;
4857 #endif
4858
4859
4860     if (s_registerCalled == 0) {
4861         // Ignore RIL_onUnsolicitedResponse before RIL_register
4862         RLOGW("RIL_onUnsolicitedResponse called before RIL_register");
4863         return;
4864     }
4865
4866     unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
4867
4868     if ((unsolResponseIndex < 0)
4869         || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) {
4870         RLOGE("unsupported unsolicited response code %d", unsolResponse);
4871         return;
4872     }
4873
4874     // Grab a wake lock if needed for this reponse,
4875     // as we exit we'll either release it immediately
4876     // or set a timer to release it later.
4877     switch (s_unsolResponses[unsolResponseIndex].wakeType) {
4878         case WAKE_PARTIAL:
4879             grabPartialWakeLock();
4880             shouldScheduleTimeout = true;
4881         break;
4882
4883         case DONT_WAKE:
4884         default:
4885             // No wake lock is grabed so don't set timeout
4886             shouldScheduleTimeout = false;
4887             break;
4888     }
4889
4890     // Mark the time this was received, doing this
4891     // after grabing the wakelock incase getting
4892     // the elapsedRealTime might cause us to goto
4893     // sleep.
4894     if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
4895         timeReceived = elapsedRealtime();
4896     }
4897
4898     appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
4899
4900     Parcel p;
4901
4902     p.writeInt32 (RESPONSE_UNSOLICITED);
4903     p.writeInt32 (unsolResponse);
4904
4905     ret = s_unsolResponses[unsolResponseIndex]
4906                 .responseFunction(p, const_cast<void*>(data), datalen);
4907     if (ret != 0) {
4908         // Problem with the response. Don't continue;
4909         goto error_exit;
4910     }
4911
4912     // some things get more payload
4913     switch(unsolResponse) {
4914         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
4915             newState = processRadioState(CALL_ONSTATEREQUEST(soc_id), soc_id);
4916             p.writeInt32(newState);
4917             appendPrintBuf("%s {%s}", printBuf,
4918                 radioStateToString(CALL_ONSTATEREQUEST(soc_id)));
4919         break;
4920
4921
4922         case RIL_UNSOL_NITZ_TIME_RECEIVED:
4923             // Store the time that this was received so the
4924             // handler of this message can account for
4925             // the time it takes to arrive and process. In
4926             // particular the system has been known to sleep
4927             // before this message can be processed.
4928             p.writeInt64(timeReceived);
4929         break;
4930     }
4931
4932 #if VDBG
4933     RLOGI("%s UNSOLICITED: %s length:%d", rilSocketIdToString(soc_id), requestToString(unsolResponse), p.dataSize());
4934 #endif
4935     ret = sendResponse(p, soc_id);
4936     if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
4937
4938         // Unfortunately, NITZ time is not poll/update like everything
4939         // else in the system. So, if the upstream client isn't connected,
4940         // keep a copy of the last NITZ response (with receive time noted
4941         // above) around so we can deliver it when it is connected
4942
4943         if (s_lastNITZTimeData != NULL) {
4944             free (s_lastNITZTimeData);
4945             s_lastNITZTimeData = NULL;
4946         }
4947
4948         s_lastNITZTimeData = malloc(p.dataSize());
4949         s_lastNITZTimeDataSize = p.dataSize();
4950         memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
4951     }
4952
4953     // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
4954     // FIXME The java code should handshake here to release wake lock
4955
4956     if (shouldScheduleTimeout) {
4957         // Cancel the previous request
4958         if (s_last_wake_timeout_info != NULL) {
4959             s_last_wake_timeout_info->userParam = (void *)1;
4960         }
4961
4962         s_last_wake_timeout_info
4963             = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
4964                                             &TIMEVAL_WAKE_TIMEOUT);
4965     }
4966
4967     // Normal exit
4968     return;
4969
4970 error_exit:
4971     if (shouldScheduleTimeout) {
4972         releaseWakeLock();
4973     }
4974 }
4975
4976 /** FIXME generalize this if you track UserCAllbackInfo, clear it
4977     when the callback occurs
4978 */
4979 static UserCallbackInfo *
4980 internalRequestTimedCallback (RIL_TimedCallback callback, void *param,
4981                                 const struct timeval *relativeTime)
4982 {
4983     struct timeval myRelativeTime;
4984     UserCallbackInfo *p_info;
4985
4986     p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
4987
4988     p_info->p_callback = callback;
4989     p_info->userParam = param;
4990
4991     if (relativeTime == NULL) {
4992         /* treat null parameter as a 0 relative time */
4993         memset (&myRelativeTime, 0, sizeof(myRelativeTime));
4994     } else {
4995         /* FIXME I think event_add's tv param is really const anyway */
4996         memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));
4997     }
4998
4999     ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);
5000
5001     ril_timer_add(&(p_info->event), &myRelativeTime);
5002
5003     triggerEvLoop();
5004     return p_info;
5005 }
5006
5007
5008 extern "C" void
5009 RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,
5010                                 const struct timeval *relativeTime) {
5011     internalRequestTimedCallback (callback, param, relativeTime);
5012 }
5013
5014 const char *
5015 failCauseToString(RIL_Errno e) {
5016     switch(e) {
5017         case RIL_E_SUCCESS: return "E_SUCCESS";
5018         case RIL_E_RADIO_NOT_AVAILABLE: return "E_RADIO_NOT_AVAILABLE";
5019         case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE";
5020         case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT";
5021         case RIL_E_SIM_PIN2: return "E_SIM_PIN2";
5022         case RIL_E_SIM_PUK2: return "E_SIM_PUK2";
5023         case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED";
5024         case RIL_E_CANCELLED: return "E_CANCELLED";
5025         case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL";
5026         case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
5027         case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY";
5028         case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT";
5029         case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME";
5030 #ifdef FEATURE_MULTIMODE_ANDROID
5031         case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
5032         case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
5033 #endif
5034         default: return "<unknown error>";
5035     }
5036 }
5037
5038 const char *
5039 radioStateToString(RIL_RadioState s) {
5040     switch(s) {
5041         case RADIO_STATE_OFF: return "RADIO_OFF";
5042         case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE";
5043         case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY";
5044         case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT";
5045         case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY";
5046         case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY";
5047         case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY";
5048         case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT";
5049         case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY";
5050         case RADIO_STATE_NV_READY:return"RADIO_NV_READY";
5051         case RADIO_STATE_ON:return"RADIO_ON";
5052         default: return "<unknown state>";
5053     }
5054 }
5055
5056 const char *
5057 callStateToString(RIL_CallState s) {
5058     switch(s) {
5059         case RIL_CALL_ACTIVE : return "ACTIVE";
5060         case RIL_CALL_HOLDING: return "HOLDING";
5061         case RIL_CALL_DIALING: return "DIALING";
5062         case RIL_CALL_ALERTING: return "ALERTING";
5063         case RIL_CALL_INCOMING: return "INCOMING";
5064         case RIL_CALL_WAITING: return "WAITING";
5065         default: return "<unknown state>";
5066     }
5067 }
5068
5069 const char *
5070 requestToString(int request) {
5071 /*
5072  cat libs/telephony/ril_commands.h \
5073  | egrep "^ *{RIL_" \
5074  | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
5075
5076
5077  cat libs/telephony/ril_unsol_commands.h \
5078  | egrep "^ *{RIL_" \
5079  | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
5080
5081 */
5082     switch(request) {
5083         case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
5084         case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
5085         case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
5086         case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
5087         case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
5088         case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
5089         case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
5090         case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
5091         case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
5092         case RIL_REQUEST_DIAL: return "DIAL";
5093         case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
5094         case RIL_REQUEST_HANGUP: return "HANGUP";
5095         case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
5096         case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
5097         case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
5098         case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
5099         case RIL_REQUEST_UDUB: return "UDUB";
5100         case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
5101         case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
5102         case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
5103         case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
5104         case RIL_REQUEST_OPERATOR: return "OPERATOR";
5105         case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
5106         case RIL_REQUEST_DTMF: return "DTMF";
5107         case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
5108         case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
5109         case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
5110         case RIL_REQUEST_SIM_IO: return "SIM_IO";
5111         case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
5112         case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
5113         case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
5114         case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
5115         case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
5116         case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
5117         case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
5118         case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
5119         case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
5120         case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
5121         case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
5122         case RIL_REQUEST_ANSWER: return "ANSWER";
5123         case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
5124         case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
5125         case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
5126         case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
5127         case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
5128         case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
5129         case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
5130         case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
5131         case RIL_REQUEST_DTMF_START: return "DTMF_START";
5132         case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
5133         case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
5134         case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
5135         case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
5136         case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
5137         case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
5138         case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
5139         case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
5140         case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
5141         case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
5142         case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
5143         case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
5144         case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
5145         case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
5146         case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
5147         case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
5148         case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
5149         case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
5150         case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
5151         case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
5152         case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
5153         case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
5154         case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
5155         case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
5156         case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
5157         case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
5158         case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
5159         case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
5160         case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
5161         case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
5162         case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
5163         case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
5164         case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
5165         case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
5166         case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
5167         case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
5168         case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
5169         case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
5170         case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
5171         case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
5172         case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
5173         case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
5174         case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
5175         case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
5176         case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
5177         case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
5178         case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
5179         case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
5180         case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
5181         case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
5182         case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
5183         case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
5184         case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
5185         case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
5186         case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
5187         case RIL_REQUEST_GET_CELL_INFO_LIST: return"GET_CELL_INFO_LIST";
5188         case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return"SET_UNSOL_CELL_INFO_LIST_RATE";
5189         case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
5190         case RIL_REQUEST_IMS_REGISTRATION_STATE: return "IMS_REGISTRATION_STATE";
5191         case RIL_REQUEST_IMS_SEND_SMS: return "IMS_SEND_SMS";
5192         case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "SIM_TRANSMIT_APDU_BASIC";
5193         case RIL_REQUEST_SIM_OPEN_CHANNEL: return "SIM_OPEN_CHANNEL";
5194         case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "SIM_CLOSE_CHANNEL";
5195         case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "SIM_TRANSMIT_APDU_CHANNEL";
5196         case RIL_REQUEST_GET_RADIO_CAPABILITY: return "RIL_REQUEST_GET_RADIO_CAPABILITY";
5197         case RIL_REQUEST_SET_RADIO_CAPABILITY: return "RIL_REQUEST_SET_RADIO_CAPABILITY";
5198         case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "SET_UICC_SUBSCRIPTION";
5199         case RIL_REQUEST_ALLOW_DATA: return "ALLOW_DATA";
5200         case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
5201         case RIL_REQUEST_SIM_AUTHENTICATION: return "SIM_AUTHENTICATION";
5202         case RIL_REQUEST_GET_DC_RT_INFO: return "GET_DC_RT_INFO";
5203         case RIL_REQUEST_SET_DC_RT_INFO_RATE: return "SET_DC_RT_INFO_RATE";
5204         case RIL_REQUEST_SET_DATA_PROFILE: return "SET_DATA_PROFILE";
5205         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
5206         case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
5207         case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
5208         case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
5209         case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
5210         case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
5211         case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
5212         case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
5213         case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
5214         case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
5215         case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
5216         case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
5217         case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
5218         case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
5219         case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
5220         case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
5221         case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
5222         case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
5223         case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
5224         case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
5225         case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
5226         case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
5227         case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
5228         case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
5229         case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
5230         case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
5231         case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
5232         case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
5233         case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
5234         case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
5235         case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
5236         case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
5237         case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
5238         case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
5239         case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
5240         case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
5241         case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: return "RESPONSE_IMS_NETWORK_STATE_CHANGED";
5242         case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: return "UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
5243         case RIL_UNSOL_SRVCC_STATE_NOTIFY: return "UNSOL_SRVCC_STATE_NOTIFY";
5244         case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "HARDWARE_CONFIG_CHANGED";
5245         case RIL_UNSOL_DC_RT_INFO_CHANGED: return "UNSOL_DC_RT_INFO_CHANGED";
5246         case RIL_REQUEST_SHUTDOWN: return "SHUTDOWN";
5247         case RIL_UNSOL_RADIO_CAPABILITY: return "RIL_UNSOL_RADIO_CAPABILITY";
5248         default: return "<unknown request>";
5249     }
5250 }
5251
5252 const char *
5253 rilSocketIdToString(RIL_SOCKET_ID socket_id)
5254 {
5255     switch(socket_id) {
5256         case RIL_SOCKET_1:
5257             return "RIL_SOCKET_1";
5258 #if (SIM_COUNT >= 2)
5259         case RIL_SOCKET_2:
5260             return "RIL_SOCKET_2";
5261 #endif
5262 #if (SIM_COUNT >= 3)
5263         case RIL_SOCKET_3:
5264             return "RIL_SOCKET_3";
5265 #endif
5266 #if (SIM_COUNT >= 4)
5267         case RIL_SOCKET_4:
5268             return "RIL_SOCKET_4";
5269 #endif
5270         default:
5271             return "not a valid RIL";
5272     }
5273 }
5274
5275 /*
5276  * Returns true for a debuggable build.
5277  */
5278 static bool isDebuggable() {
5279     char debuggable[PROP_VALUE_MAX];
5280     property_get("ro.debuggable", debuggable, "0");
5281     if (strcmp(debuggable, "1") == 0) {
5282         return true;
5283     }
5284     return false;
5285 }
5286
5287 } /* namespace android */
5288
5289 void rilEventAddWakeup_helper(struct ril_event *ev) {
5290     android::rilEventAddWakeup(ev);
5291 }
5292
5293 void listenCallback_helper(int fd, short flags, void *param) {
5294     android::listenCallback(fd, flags, param);
5295 }
5296
5297 int blockingWrite_helper(int fd, void *buffer, size_t len) {
5298     return android::blockingWrite(fd, buffer, len);
5299 }