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
  22 #include <telephony/ril.h>
  23 #include <telephony/ril_cdma_sms.h>
  24 #include <cutils/sockets.h>
  25 #include <cutils/jstring.h>
  26 #include <cutils/record_stream.h>
  27 #include <utils/Log.h>
  28 #include <utils/SystemClock.h>
  29 #include <pthread.h>
  30 #include <binder/Parcel.h>
  31 #include <cutils/jstring.h>
  32
  33 #include <sys/types.h>
  34 #include <pwd.h>
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <stdarg.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <fcntl.h>
  42 #include <time.h>
  43 #include <errno.h>
  44 #include <assert.h>
  45 #include <ctype.h>
  46 #include <alloca.h>
  47 #include <sys/un.h>
  48 #include <assert.h>
  49 #include <netinet/in.h>
  50 #include <cutils/properties.h>
  51
  52 #include <ril_event.h>
  53
  54 namespace android {
  55
  56 #define PHONE_PROCESS "radio"
  57
  58 #define SOCKET_NAME_RIL "rild"
  59 #define SOCKET_NAME_RIL_DEBUG "rild-debug"
  60
  61 #define ANDROID_WAKE_LOCK_NAME "radio-interface"
  62
  63
  64 #define PROPERTY_RIL_IMPL "gsm.version.ril-impl"
  65
  66 // match with constant in RIL.java
  67 #define MAX_COMMAND_BYTES (8 * 1024)
  68
  69 // Basically: memset buffers that the client library
  70 // shouldn't be using anymore in an attempt to find
  71 // memory usage issues sooner.
  72 #define MEMSET_FREED 1
  73
  74 #define NUM_ELEMS(a)     (sizeof (a) / sizeof (a)[0])
  75
  76 #define MIN(a,b) ((a)<(b) ? (a) : (b))
  77
  78 /* Constants for response types */
  79 #define RESPONSE_SOLICITED 0
  80 #define RESPONSE_UNSOLICITED 1
  81
  82 /* Negative values for private RIL errno's */
  83 #define RIL_ERRNO_INVALID_RESPONSE -1
  84
  85 // request, response, and unsolicited msg print macro
  86 #define PRINTBUF_SIZE 8096
  87
  88 // Enable RILC log
  89 #define RILC_LOG 0
  90
  91 #if RILC_LOG
  92     #define startRequest           sprintf(printBuf, "(")
  93     #define closeRequest           sprintf(printBuf, "%s)", printBuf)
  94     #define printRequest(token, req)           \
  95             ALOGD("[%04d]> %s %s", token, requestToString(req), printBuf)
  96
  97     #define startResponse           sprintf(printBuf, "%s {", printBuf)
  98     #define closeResponse           sprintf(printBuf, "%s}", printBuf)
  99     #define printResponse           ALOGD("%s", printBuf)
 100
 101     #define clearPrintBuf           printBuf[0] = 0
 102     #define removeLastChar          printBuf[strlen(printBuf)-1] = 0
 103     #define appendPrintBuf(x...)    sprintf(printBuf, x)
 104 #else
 105     #define startRequest
 106     #define closeRequest
 107     #define printRequest(token, req)
 108     #define startResponse
 109     #define closeResponse
 110     #define printResponse
 111     #define clearPrintBuf
 112     #define removeLastChar
 113     #define appendPrintBuf(x...)
 114 #endif
 115
 116 enum WakeType {DONT_WAKE, WAKE_PARTIAL};
 117
 118 typedef struct {
 119     int requestNumber;
 120     void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);
 121     int(*responseFunction) (Parcel &p, void *response, size_t responselen);
 122 } CommandInfo;
 123
 124 typedef struct {
 125     int requestNumber;
 126     int (*responseFunction) (Parcel &p, void *response, size_t responselen);
 127     WakeType wakeType;
 128 } UnsolResponseInfo;
 129
 130 typedef struct RequestInfo {
 131     int32_t token;      //this is not RIL_Token
 132     CommandInfo *pCI;
 133     struct RequestInfo *p_next;
 134     char cancelled;
 135     char local;         // responses to local commands do not go back to command process
 136 } RequestInfo;
 137
 138 typedef struct UserCallbackInfo {
 139     RIL_TimedCallback p_callback;
 140     void *userParam;
 141     struct ril_event event;
 142     struct UserCallbackInfo *p_next;
 143 } UserCallbackInfo;
 144
 145
 146 /*******************************************************************/
 147
 148 RIL_RadioFunctions s_callbacks = {0, NULL, NULL, NULL, NULL, NULL};
 149 static int s_registerCalled = 0;
 150
 151 static pthread_t s_tid_dispatch;
 152 static pthread_t s_tid_reader;
 153 static int s_started = 0;
 154
 155 static int s_fdListen = -1;
 156 static int s_fdCommand = -1;
 157 static int s_fdDebug = -1;
 158
 159 static int s_fdWakeupRead;
 160 static int s_fdWakeupWrite;
 161
 162 static struct ril_event s_commands_event;
 163 static struct ril_event s_wakeupfd_event;
 164 static struct ril_event s_listen_event;
 165 static struct ril_event s_wake_timeout_event;
 166 static struct ril_event s_debug_event;
 167
 168
 169 static const struct timeval TIMEVAL_WAKE_TIMEOUT = {1,0};
 170
 171 static pthread_mutex_t s_pendingRequestsMutex = PTHREAD_MUTEX_INITIALIZER;
 172 static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER;
 173 static pthread_mutex_t s_startupMutex = PTHREAD_MUTEX_INITIALIZER;
 174 static pthread_cond_t s_startupCond = PTHREAD_COND_INITIALIZER;
 175
 176 static pthread_mutex_t s_dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
 177 static pthread_cond_t s_dispatchCond = PTHREAD_COND_INITIALIZER;
 178
 179 static RequestInfo *s_pendingRequests = NULL;
 180
 181 static RequestInfo *s_toDispatchHead = NULL;
 182 static RequestInfo *s_toDispatchTail = NULL;
 183
 184 static UserCallbackInfo *s_last_wake_timeout_info = NULL;
 185
 186 static void *s_lastNITZTimeData = NULL;
 187 static size_t s_lastNITZTimeDataSize;
 188
 189 #if RILC_LOG
 190     static char printBuf[PRINTBUF_SIZE];
 191 #endif
 192
 193 /*******************************************************************/
 194
 195 static void dispatchVoid (Parcel& p, RequestInfo *pRI);
 196 static void dispatchString (Parcel& p, RequestInfo *pRI);
 197 static void dispatchStrings (Parcel& p, RequestInfo *pRI);
 198 static void dispatchInts (Parcel& p, RequestInfo *pRI);
 199 static void dispatchDial (Parcel& p, RequestInfo *pRI);
 200 static void dispatchSIM_IO (Parcel& p, RequestInfo *pRI);
 201 static void dispatchCallForward(Parcel& p, RequestInfo *pRI);
 202 static void dispatchRaw(Parcel& p, RequestInfo *pRI);
 203 static void dispatchSmsWrite (Parcel &p, RequestInfo *pRI);
 204 static void dispatchDataCall (Parcel& p, RequestInfo *pRI);
 205 static void dispatchVoiceRadioTech (Parcel& p, RequestInfo *pRI);
 206 static void dispatchCdmaSubscriptionSource (Parcel& p, RequestInfo *pRI);
 207
 208 static void dispatchCdmaSms(Parcel &p, RequestInfo *pRI);
 209 static void dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI);
 210 static void dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI);
 211 static void dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI);
 212 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI);
 213 static int responseInts(Parcel &p, void *response, size_t responselen);
 214 static int responseStrings(Parcel &p, void *response, size_t responselen);
 215 static int responseString(Parcel &p, void *response, size_t responselen);
 216 static int responseVoid(Parcel &p, void *response, size_t responselen);
 217 static int responseCallList(Parcel &p, void *response, size_t responselen);
 218 static int responseSMS(Parcel &p, void *response, size_t responselen);
 219 static int responseSIM_IO(Parcel &p, void *response, size_t responselen);
 220 static int responseCallForwards(Parcel &p, void *response, size_t responselen);
 221 static int responseDataCallList(Parcel &p, void *response, size_t responselen);
 222 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen);
 223 static int responseRaw(Parcel &p, void *response, size_t responselen);
 224 static int responseSsn(Parcel &p, void *response, size_t responselen);
 225 static int responseSimStatus(Parcel &p, void *response, size_t responselen);
 226 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen);
 227 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen);
 228 static int responseCdmaSms(Parcel &p, void *response, size_t responselen);
 229 static int responseCellList(Parcel &p, void *response, size_t responselen);
 230 static int responseCdmaInformationRecords(Parcel &p,void *response, size_t responselen);
 231 static int responseRilSignalStrength(Parcel &p,void *response, size_t responselen);
 232 static int responseCallRing(Parcel &p, void *response, size_t responselen);
 233 static int responseCdmaSignalInfoRecord(Parcel &p,void *response, size_t responselen);
 234 static int responseCdmaCallWaiting(Parcel &p,void *response, size_t responselen);
 235 static int responseSimRefresh(Parcel &p, void *response, size_t responselen);
 236
 237 static int decodeVoiceRadioTechnology (RIL_RadioState radioState);
 238 static int decodeCdmaSubscriptionSource (RIL_RadioState radioState);
 239 static RIL_RadioState processRadioState(RIL_RadioState newRadioState);
 240
 241 extern "C" const char * requestToString(int request);
 242 extern "C" const char * failCauseToString(RIL_Errno);
 243 extern "C" const char * callStateToString(RIL_CallState);
 244 extern "C" const char * radioStateToString(RIL_RadioState);
 245
 246 #ifdef RIL_SHLIB
 247 extern "C" void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
 248                                 size_t datalen);
 249 #endif
 250
 251 static UserCallbackInfo * internalRequestTimedCallback
 252     (RIL_TimedCallback callback, void *param,
 253         const struct timeval *relativeTime);
 254
 255 /** Index == requestNumber */
 256 static CommandInfo s_commands[] = {
 257 #include "ril_commands.h"
 258 };
 259
 260 static UnsolResponseInfo s_unsolResponses[] = {
 261 #include "ril_unsol_commands.h"
 262 };
 263
 264 /* For older RILs that do not support new commands RIL_REQUEST_VOICE_RADIO_TECH and
 265    RIL_UNSOL_VOICE_RADIO_TECH_CHANGED messages, decode the voice radio tech from
 266    radio state message and store it. Every time there is a change in Radio State
 267    check to see if voice radio tech changes and notify telephony
 268  */
 269 int voiceRadioTech = -1;
 270
 271 /* For older RILs that do not support new commands RIL_REQUEST_GET_CDMA_SUBSCRIPTION_SOURCE
 272    and RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED messages, decode the subscription
 273    source from radio state and store it. Every time there is a change in Radio State
 274    check to see if subscription source changed and notify telephony
 275  */
 276 int cdmaSubscriptionSource = -1;
 277
 278 /* For older RILs that do not send RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, decode the
 279    SIM/RUIM state from radio state and store it. Every time there is a change in Radio State,
 280    check to see if SIM/RUIM status changed and notify telephony
 281  */
 282 int simRuimStatus = -1;
 283
 284 static char *
 285 strdupReadString(Parcel &p) {
 286     size_t stringlen;
 287     const char16_t *s16;
 288
 289     s16 = p.readString16Inplace(&stringlen);
 290
 291     return strndup16to8(s16, stringlen);
 292 }
 293
 294 static void writeStringToParcel(Parcel &p, const char *s) {
 295     char16_t *s16;
 296     size_t s16_len;
 297     s16 = strdup8to16(s, &s16_len);
 298     p.writeString16(s16, s16_len);
 299     free(s16);
 300 }
 301
 302
 303 static void
 304 memsetString (char *s) {
 305     if (s != NULL) {
 306         memset (s, 0, strlen(s));
 307     }
 308 }
 309
 310 void   nullParcelReleaseFunction (const uint8_t* data, size_t dataSize,
 311                                     const size_t* objects, size_t objectsSize,
 312                                         void* cookie) {
 313     // do nothing -- the data reference lives longer than the Parcel object
 314 }
 315
 316 /**
 317  * To be called from dispatch thread
 318  * Issue a single local request, ensuring that the response
 319  * is not sent back up to the command process
 320  */
 321 static void
 322 issueLocalRequest(int request, void *data, int len) {
 323     RequestInfo *pRI;
 324     int ret;
 325
 326     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
 327
 328     pRI->local = 1;
 329     pRI->token = 0xffffffff;        // token is not used in this context
 330     pRI->pCI = &(s_commands[request]);
 331
 332     ret = pthread_mutex_lock(&s_pendingRequestsMutex);
 333     assert (ret == 0);
 334
 335     pRI->p_next = s_pendingRequests;
 336     s_pendingRequests = pRI;
 337
 338     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
 339     assert (ret == 0);
 340
 341     ALOGD("C[locl]> %s", requestToString(request));
 342
 343     s_callbacks.onRequest(request, data, len, pRI);
 344 }
 345
 346
 347
 348 static int
 349 processCommandBuffer(void *buffer, size_t buflen) {
 350     Parcel p;
 351     status_t status;
 352     int32_t request;
 353     int32_t token;
 354     RequestInfo *pRI;
 355     int ret;
 356
 357     p.setData((uint8_t *) buffer, buflen);
 358
 359     // status checked at end
 360     status = p.readInt32(&request);
 361     status = p.readInt32 (&token);
 362
 363     if (status != NO_ERROR) {
 364         ALOGE("invalid request block");
 365         return 0;
 366     }
 367
 368     if (request < 1 || request >= (int32_t)NUM_ELEMS(s_commands)) {
 369         ALOGE("unsupported request code %d token %d", request, token);
 370         // FIXME this should perhaps return a response
 371         return 0;
 372     }
 373
 374
 375     pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));
 376
 377     pRI->token = token;
 378     pRI->pCI = &(s_commands[request]);
 379
 380     ret = pthread_mutex_lock(&s_pendingRequestsMutex);
 381     assert (ret == 0);
 382
 383     pRI->p_next = s_pendingRequests;
 384     s_pendingRequests = pRI;
 385
 386     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
 387     assert (ret == 0);
 388
 389 /*    sLastDispatchedToken = token; */
 390
 391     pRI->pCI->dispatchFunction(p, pRI);
 392
 393     return 0;
 394 }
 395
 396 static void
 397 invalidCommandBlock (RequestInfo *pRI) {
 398     ALOGE("invalid command block for token %d request %s",
 399                 pRI->token, requestToString(pRI->pCI->requestNumber));
 400 }
 401
 402 /** Callee expects NULL */
 403 static void
 404 dispatchVoid (Parcel& p, RequestInfo *pRI) {
 405     clearPrintBuf;
 406     printRequest(pRI->token, pRI->pCI->requestNumber);
 407     s_callbacks.onRequest(pRI->pCI->requestNumber, NULL, 0, pRI);
 408 }
 409
 410 /** Callee expects const char * */
 411 static void
 412 dispatchString (Parcel& p, RequestInfo *pRI) {
 413     status_t status;
 414     size_t datalen;
 415     size_t stringlen;
 416     char *string8 = NULL;
 417
 418     string8 = strdupReadString(p);
 419
 420     startRequest;
 421     appendPrintBuf("%s%s", printBuf, string8);
 422     closeRequest;
 423     printRequest(pRI->token, pRI->pCI->requestNumber);
 424
 425     s_callbacks.onRequest(pRI->pCI->requestNumber, string8,
 426                        sizeof(char *), pRI);
 427
 428 #ifdef MEMSET_FREED
 429     memsetString(string8);
 430 #endif
 431
 432     free(string8);
 433     return;
 434 invalid:
 435     invalidCommandBlock(pRI);
 436     return;
 437 }
 438
 439 /** Callee expects const char ** */
 440 static void
 441 dispatchStrings (Parcel &p, RequestInfo *pRI) {
 442     int32_t countStrings;
 443     status_t status;
 444     size_t datalen;
 445     char **pStrings;
 446
 447     status = p.readInt32 (&countStrings);
 448
 449     if (status != NO_ERROR) {
 450         goto invalid;
 451     }
 452
 453     startRequest;
 454     if (countStrings == 0) {
 455         // just some non-null pointer
 456         pStrings = (char **)alloca(sizeof(char *));
 457         datalen = 0;
 458     } else if (((int)countStrings) == -1) {
 459         pStrings = NULL;
 460         datalen = 0;
 461     } else {
 462         datalen = sizeof(char *) * countStrings;
 463
 464         pStrings = (char **)alloca(datalen);
 465
 466         for (int i = 0 ; i < countStrings ; i++) {
 467             pStrings[i] = strdupReadString(p);
 468             appendPrintBuf("%s%s,", printBuf, pStrings[i]);
 469         }
 470     }
 471     removeLastChar;
 472     closeRequest;
 473     printRequest(pRI->token, pRI->pCI->requestNumber);
 474
 475     s_callbacks.onRequest(pRI->pCI->requestNumber, pStrings, datalen, pRI);
 476
 477     if (pStrings != NULL) {
 478         for (int i = 0 ; i < countStrings ; i++) {
 479 #ifdef MEMSET_FREED
 480             memsetString (pStrings[i]);
 481 #endif
 482             free(pStrings[i]);
 483         }
 484
 485 #ifdef MEMSET_FREED
 486         memset(pStrings, 0, datalen);
 487 #endif
 488     }
 489
 490     return;
 491 invalid:
 492     invalidCommandBlock(pRI);
 493     return;
 494 }
 495
 496 /** Callee expects const int * */
 497 static void
 498 dispatchInts (Parcel &p, RequestInfo *pRI) {
 499     int32_t count;
 500     status_t status;
 501     size_t datalen;
 502     int *pInts;
 503
 504     status = p.readInt32 (&count);
 505
 506     if (status != NO_ERROR || count == 0) {
 507         goto invalid;
 508     }
 509
 510     datalen = sizeof(int) * count;
 511     pInts = (int *)alloca(datalen);
 512
 513     startRequest;
 514     for (int i = 0 ; i < count ; i++) {
 515         int32_t t;
 516
 517         status = p.readInt32(&t);
 518         pInts[i] = (int)t;
 519         appendPrintBuf("%s%d,", printBuf, t);
 520
 521         if (status != NO_ERROR) {
 522             goto invalid;
 523         }
 524    }
 525    removeLastChar;
 526    closeRequest;
 527    printRequest(pRI->token, pRI->pCI->requestNumber);
 528
 529    s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<int *>(pInts),
 530                        datalen, pRI);
 531
 532 #ifdef MEMSET_FREED
 533     memset(pInts, 0, datalen);
 534 #endif
 535
 536     return;
 537 invalid:
 538     invalidCommandBlock(pRI);
 539     return;
 540 }
 541
 542
 543 /**
 544  * Callee expects const RIL_SMS_WriteArgs *
 545  * Payload is:
 546  *   int32_t status
 547  *   String pdu
 548  */
 549 static void
 550 dispatchSmsWrite (Parcel &p, RequestInfo *pRI) {
 551     RIL_SMS_WriteArgs args;
 552     int32_t t;
 553     status_t status;
 554
 555     memset (&args, 0, sizeof(args));
 556
 557     status = p.readInt32(&t);
 558     args.status = (int)t;
 559
 560     args.pdu = strdupReadString(p);
 561
 562     if (status != NO_ERROR || args.pdu == NULL) {
 563         goto invalid;
 564     }
 565
 566     args.smsc = strdupReadString(p);
 567
 568     startRequest;
 569     appendPrintBuf("%s%d,%s,smsc=%s", printBuf, args.status,
 570         (char*)args.pdu,  (char*)args.smsc);
 571     closeRequest;
 572     printRequest(pRI->token, pRI->pCI->requestNumber);
 573
 574     s_callbacks.onRequest(pRI->pCI->requestNumber, &args, sizeof(args), pRI);
 575
 576 #ifdef MEMSET_FREED
 577     memsetString (args.pdu);
 578 #endif
 579
 580     free (args.pdu);
 581
 582 #ifdef MEMSET_FREED
 583     memset(&args, 0, sizeof(args));
 584 #endif
 585
 586     return;
 587 invalid:
 588     invalidCommandBlock(pRI);
 589     return;
 590 }
 591
 592 /**
 593  * Callee expects const RIL_Dial *
 594  * Payload is:
 595  *   String address
 596  *   int32_t clir
 597  */
 598 static void
 599 dispatchDial (Parcel &p, RequestInfo *pRI) {
 600     RIL_Dial dial;
 601     RIL_UUS_Info uusInfo;
 602     int32_t sizeOfDial;
 603     int32_t t;
 604     int32_t uusPresent;
 605     status_t status;
 606
 607     memset (&dial, 0, sizeof(dial));
 608
 609     dial.address = strdupReadString(p);
 610
 611     status = p.readInt32(&t);
 612     dial.clir = (int)t;
 613
 614     if (status != NO_ERROR || dial.address == NULL) {
 615         goto invalid;
 616     }
 617
 618     if (s_callbacks.version < 3) { // Remove when partners upgrade to version 3
 619         uusPresent = 0;
 620         sizeOfDial = sizeof(dial) - sizeof(RIL_UUS_Info *);
 621     } else {
 622         status = p.readInt32(&uusPresent);
 623
 624         if (status != NO_ERROR) {
 625             goto invalid;
 626         }
 627
 628         if (uusPresent == 0) {
 629             dial.uusInfo = NULL;
 630         } else {
 631             int32_t len;
 632
 633             memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
 634
 635             status = p.readInt32(&t);
 636             uusInfo.uusType = (RIL_UUS_Type) t;
 637
 638             status = p.readInt32(&t);
 639             uusInfo.uusDcs = (RIL_UUS_DCS) t;
 640
 641             status = p.readInt32(&len);
 642             if (status != NO_ERROR) {
 643                 goto invalid;
 644             }
 645
 646             // The java code writes -1 for null arrays
 647             if (((int) len) == -1) {
 648                 uusInfo.uusData = NULL;
 649                 len = 0;
 650             } else {
 651                 uusInfo.uusData = (char*) p.readInplace(len);
 652             }
 653
 654             uusInfo.uusLength = len;
 655             dial.uusInfo = &uusInfo;
 656         }
 657         sizeOfDial = sizeof(dial);
 658     }
 659
 660     startRequest;
 661     appendPrintBuf("%snum=%s,clir=%d", printBuf, dial.address, dial.clir);
 662     if (uusPresent) {
 663         appendPrintBuf("%s,uusType=%d,uusDcs=%d,uusLen=%d", printBuf,
 664                 dial.uusInfo->uusType, dial.uusInfo->uusDcs,
 665                 dial.uusInfo->uusLength);
 666     }
 667     closeRequest;
 668     printRequest(pRI->token, pRI->pCI->requestNumber);
 669
 670     s_callbacks.onRequest(pRI->pCI->requestNumber, &dial, sizeOfDial, pRI);
 671
 672 #ifdef MEMSET_FREED
 673     memsetString (dial.address);
 674 #endif
 675
 676     free (dial.address);
 677
 678 #ifdef MEMSET_FREED
 679     memset(&uusInfo, 0, sizeof(RIL_UUS_Info));
 680     memset(&dial, 0, sizeof(dial));
 681 #endif
 682
 683     return;
 684 invalid:
 685     invalidCommandBlock(pRI);
 686     return;
 687 }
 688
 689 /**
 690  * Callee expects const RIL_SIM_IO *
 691  * Payload is:
 692  *   int32_t command
 693  *   int32_t fileid
 694  *   String path
 695  *   int32_t p1, p2, p3
 696  *   String data
 697  *   String pin2
 698  *   String aidPtr
 699  */
 700 static void
 701 dispatchSIM_IO (Parcel &p, RequestInfo *pRI) {
 702     union RIL_SIM_IO {
 703         RIL_SIM_IO_v6 v6;
 704         RIL_SIM_IO_v5 v5;
 705     } simIO;
 706
 707     int32_t t;
 708     int size;
 709     status_t status;
 710
 711     memset (&simIO, 0, sizeof(simIO));
 712
 713     // note we only check status at the end
 714
 715     status = p.readInt32(&t);
 716     simIO.v6.command = (int)t;
 717
 718     status = p.readInt32(&t);
 719     simIO.v6.fileid = (int)t;
 720
 721     simIO.v6.path = strdupReadString(p);
 722
 723     status = p.readInt32(&t);
 724     simIO.v6.p1 = (int)t;
 725
 726     status = p.readInt32(&t);
 727     simIO.v6.p2 = (int)t;
 728
 729     status = p.readInt32(&t);
 730     simIO.v6.p3 = (int)t;
 731
 732     simIO.v6.data = strdupReadString(p);
 733     simIO.v6.pin2 = strdupReadString(p);
 734     simIO.v6.aidPtr = strdupReadString(p);
 735
 736     startRequest;
 737     appendPrintBuf("%scmd=0x%X,efid=0x%X,path=%s,%d,%d,%d,%s,pin2=%s,aid=%s", printBuf,
 738         simIO.v6.command, simIO.v6.fileid, (char*)simIO.v6.path,
 739         simIO.v6.p1, simIO.v6.p2, simIO.v6.p3,
 740         (char*)simIO.v6.data,  (char*)simIO.v6.pin2, simIO.v6.aidPtr);
 741     closeRequest;
 742     printRequest(pRI->token, pRI->pCI->requestNumber);
 743
 744     if (status != NO_ERROR) {
 745         goto invalid;
 746     }
 747
 748     size = (s_callbacks.version < 6) ? sizeof(simIO.v5) : sizeof(simIO.v6);
 749     s_callbacks.onRequest(pRI->pCI->requestNumber, &simIO, size, pRI);
 750
 751 #ifdef MEMSET_FREED
 752     memsetString (simIO.v6.path);
 753     memsetString (simIO.v6.data);
 754     memsetString (simIO.v6.pin2);
 755     memsetString (simIO.v6.aidPtr);
 756 #endif
 757
 758     free (simIO.v6.path);
 759     free (simIO.v6.data);
 760     free (simIO.v6.pin2);
 761     free (simIO.v6.aidPtr);
 762
 763 #ifdef MEMSET_FREED
 764     memset(&simIO, 0, sizeof(simIO));
 765 #endif
 766
 767     return;
 768 invalid:
 769     invalidCommandBlock(pRI);
 770     return;
 771 }
 772
 773 /**
 774  * Callee expects const RIL_CallForwardInfo *
 775  * Payload is:
 776  *  int32_t status/action
 777  *  int32_t reason
 778  *  int32_t serviceCode
 779  *  int32_t toa
 780  *  String number  (0 length -> null)
 781  *  int32_t timeSeconds
 782  */
 783 static void
 784 dispatchCallForward(Parcel &p, RequestInfo *pRI) {
 785     RIL_CallForwardInfo cff;
 786     int32_t t;
 787     status_t status;
 788
 789     memset (&cff, 0, sizeof(cff));
 790
 791     // note we only check status at the end
 792
 793     status = p.readInt32(&t);
 794     cff.status = (int)t;
 795
 796     status = p.readInt32(&t);
 797     cff.reason = (int)t;
 798
 799     status = p.readInt32(&t);
 800     cff.serviceClass = (int)t;
 801
 802     status = p.readInt32(&t);
 803     cff.toa = (int)t;
 804
 805     cff.number = strdupReadString(p);
 806
 807     status = p.readInt32(&t);
 808     cff.timeSeconds = (int)t;
 809
 810     if (status != NO_ERROR) {
 811         goto invalid;
 812     }
 813
 814     // special case: number 0-length fields is null
 815
 816     if (cff.number != NULL && strlen (cff.number) == 0) {
 817         cff.number = NULL;
 818     }
 819
 820     startRequest;
 821     appendPrintBuf("%sstat=%d,reason=%d,serv=%d,toa=%d,%s,tout=%d", printBuf,
 822         cff.status, cff.reason, cff.serviceClass, cff.toa,
 823         (char*)cff.number, cff.timeSeconds);
 824     closeRequest;
 825     printRequest(pRI->token, pRI->pCI->requestNumber);
 826
 827     s_callbacks.onRequest(pRI->pCI->requestNumber, &cff, sizeof(cff), pRI);
 828
 829 #ifdef MEMSET_FREED
 830     memsetString(cff.number);
 831 #endif
 832
 833     free (cff.number);
 834
 835 #ifdef MEMSET_FREED
 836     memset(&cff, 0, sizeof(cff));
 837 #endif
 838
 839     return;
 840 invalid:
 841     invalidCommandBlock(pRI);
 842     return;
 843 }
 844
 845
 846 static void
 847 dispatchRaw(Parcel &p, RequestInfo *pRI) {
 848     int32_t len;
 849     status_t status;
 850     const void *data;
 851
 852     status = p.readInt32(&len);
 853
 854     if (status != NO_ERROR) {
 855         goto invalid;
 856     }
 857
 858     // The java code writes -1 for null arrays
 859     if (((int)len) == -1) {
 860         data = NULL;
 861         len = 0;
 862     }
 863
 864     data = p.readInplace(len);
 865
 866     startRequest;
 867     appendPrintBuf("%sraw_size=%d", printBuf, len);
 868     closeRequest;
 869     printRequest(pRI->token, pRI->pCI->requestNumber);
 870
 871     s_callbacks.onRequest(pRI->pCI->requestNumber, const_cast<void *>(data), len, pRI);
 872
 873     return;
 874 invalid:
 875     invalidCommandBlock(pRI);
 876     return;
 877 }
 878
 879 static void
 880 dispatchCdmaSms(Parcel &p, RequestInfo *pRI) {
 881     RIL_CDMA_SMS_Message rcsm;
 882     int32_t  t;
 883     uint8_t ut;
 884     status_t status;
 885     int32_t digitCount;
 886     int digitLimit;
 887
 888     memset(&rcsm, 0, sizeof(rcsm));
 889
 890     status = p.readInt32(&t);
 891     rcsm.uTeleserviceID = (int) t;
 892
 893     status = p.read(&ut,sizeof(ut));
 894     rcsm.bIsServicePresent = (uint8_t) ut;
 895
 896     status = p.readInt32(&t);
 897     rcsm.uServicecategory = (int) t;
 898
 899     status = p.readInt32(&t);
 900     rcsm.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
 901
 902     status = p.readInt32(&t);
 903     rcsm.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
 904
 905     status = p.readInt32(&t);
 906     rcsm.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
 907
 908     status = p.readInt32(&t);
 909     rcsm.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
 910
 911     status = p.read(&ut,sizeof(ut));
 912     rcsm.sAddress.number_of_digits= (uint8_t) ut;
 913
 914     digitLimit= MIN((rcsm.sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
 915     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
 916         status = p.read(&ut,sizeof(ut));
 917         rcsm.sAddress.digits[digitCount] = (uint8_t) ut;
 918     }
 919
 920     status = p.readInt32(&t);
 921     rcsm.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
 922
 923     status = p.read(&ut,sizeof(ut));
 924     rcsm.sSubAddress.odd = (uint8_t) ut;
 925
 926     status = p.read(&ut,sizeof(ut));
 927     rcsm.sSubAddress.number_of_digits = (uint8_t) ut;
 928
 929     digitLimit= MIN((rcsm.sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
 930     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
 931         status = p.read(&ut,sizeof(ut));
 932         rcsm.sSubAddress.digits[digitCount] = (uint8_t) ut;
 933     }
 934
 935     status = p.readInt32(&t);
 936     rcsm.uBearerDataLen = (int) t;
 937
 938     digitLimit= MIN((rcsm.uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
 939     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
 940         status = p.read(&ut, sizeof(ut));
 941         rcsm.aBearerData[digitCount] = (uint8_t) ut;
 942     }
 943
 944     if (status != NO_ERROR) {
 945         goto invalid;
 946     }
 947
 948     startRequest;
 949     appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
 950             sAddress.digit_mode=%d, sAddress.Number_mode=%d, sAddress.number_type=%d, ",
 951             printBuf, rcsm.uTeleserviceID,rcsm.bIsServicePresent,rcsm.uServicecategory,
 952             rcsm.sAddress.digit_mode, rcsm.sAddress.number_mode,rcsm.sAddress.number_type);
 953     closeRequest;
 954
 955     printRequest(pRI->token, pRI->pCI->requestNumber);
 956
 957     s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsm, sizeof(rcsm),pRI);
 958
 959 #ifdef MEMSET_FREED
 960     memset(&rcsm, 0, sizeof(rcsm));
 961 #endif
 962
 963     return;
 964
 965 invalid:
 966     invalidCommandBlock(pRI);
 967     return;
 968 }
 969
 970 static void
 971 dispatchCdmaSmsAck(Parcel &p, RequestInfo *pRI) {
 972     RIL_CDMA_SMS_Ack rcsa;
 973     int32_t  t;
 974     status_t status;
 975     int32_t digitCount;
 976
 977     memset(&rcsa, 0, sizeof(rcsa));
 978
 979     status = p.readInt32(&t);
 980     rcsa.uErrorClass = (RIL_CDMA_SMS_ErrorClass) t;
 981
 982     status = p.readInt32(&t);
 983     rcsa.uSMSCauseCode = (int) t;
 984
 985     if (status != NO_ERROR) {
 986         goto invalid;
 987     }
 988
 989     startRequest;
 990     appendPrintBuf("%suErrorClass=%d, uTLStatus=%d, ",
 991             printBuf, rcsa.uErrorClass, rcsa.uSMSCauseCode);
 992     closeRequest;
 993
 994     printRequest(pRI->token, pRI->pCI->requestNumber);
 995
 996     s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsa, sizeof(rcsa),pRI);
 997
 998 #ifdef MEMSET_FREED
 999     memset(&rcsa, 0, sizeof(rcsa));
1000 #endif
1001
1002     return;
1003
1004 invalid:
1005     invalidCommandBlock(pRI);
1006     return;
1007 }
1008
1009 static void
1010 dispatchGsmBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1011     int32_t t;
1012     status_t status;
1013     int32_t num;
1014
1015     status = p.readInt32(&num);
1016     if (status != NO_ERROR) {
1017         goto invalid;
1018     }
1019
1020     RIL_GSM_BroadcastSmsConfigInfo gsmBci[num];
1021     RIL_GSM_BroadcastSmsConfigInfo *gsmBciPtrs[num];
1022
1023     startRequest;
1024     for (int i = 0 ; i < num ; i++ ) {
1025         gsmBciPtrs[i] = &gsmBci[i];
1026
1027         status = p.readInt32(&t);
1028         gsmBci[i].fromServiceId = (int) t;
1029
1030         status = p.readInt32(&t);
1031         gsmBci[i].toServiceId = (int) t;
1032
1033         status = p.readInt32(&t);
1034         gsmBci[i].fromCodeScheme = (int) t;
1035
1036         status = p.readInt32(&t);
1037         gsmBci[i].toCodeScheme = (int) t;
1038
1039         status = p.readInt32(&t);
1040         gsmBci[i].selected = (uint8_t) t;
1041
1042         appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId =%d, \
1043               fromCodeScheme=%d, toCodeScheme=%d, selected =%d]", printBuf, i,
1044               gsmBci[i].fromServiceId, gsmBci[i].toServiceId,
1045               gsmBci[i].fromCodeScheme, gsmBci[i].toCodeScheme,
1046               gsmBci[i].selected);
1047     }
1048     closeRequest;
1049
1050     if (status != NO_ERROR) {
1051         goto invalid;
1052     }
1053
1054     s_callbacks.onRequest(pRI->pCI->requestNumber,
1055                           gsmBciPtrs,
1056                           num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *),
1057                           pRI);
1058
1059 #ifdef MEMSET_FREED
1060     memset(gsmBci, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo));
1061     memset(gsmBciPtrs, 0, num * sizeof(RIL_GSM_BroadcastSmsConfigInfo *));
1062 #endif
1063
1064     return;
1065
1066 invalid:
1067     invalidCommandBlock(pRI);
1068     return;
1069 }
1070
1071 static void
1072 dispatchCdmaBrSmsCnf(Parcel &p, RequestInfo *pRI) {
1073     int32_t t;
1074     status_t status;
1075     int32_t num;
1076
1077     status = p.readInt32(&num);
1078     if (status != NO_ERROR) {
1079         goto invalid;
1080     }
1081
1082     RIL_CDMA_BroadcastSmsConfigInfo cdmaBci[num];
1083     RIL_CDMA_BroadcastSmsConfigInfo *cdmaBciPtrs[num];
1084
1085     startRequest;
1086     for (int i = 0 ; i < num ; i++ ) {
1087         cdmaBciPtrs[i] = &cdmaBci[i];
1088
1089         status = p.readInt32(&t);
1090         cdmaBci[i].service_category = (int) t;
1091
1092         status = p.readInt32(&t);
1093         cdmaBci[i].language = (int) t;
1094
1095         status = p.readInt32(&t);
1096         cdmaBci[i].selected = (uint8_t) t;
1097
1098         appendPrintBuf("%s [%d: service_category=%d, language =%d, \
1099               entries.bSelected =%d]", printBuf, i, cdmaBci[i].service_category,
1100               cdmaBci[i].language, cdmaBci[i].selected);
1101     }
1102     closeRequest;
1103
1104     if (status != NO_ERROR) {
1105         goto invalid;
1106     }
1107
1108     s_callbacks.onRequest(pRI->pCI->requestNumber,
1109                           cdmaBciPtrs,
1110                           num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *),
1111                           pRI);
1112
1113 #ifdef MEMSET_FREED
1114     memset(cdmaBci, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo));
1115     memset(cdmaBciPtrs, 0, num * sizeof(RIL_CDMA_BroadcastSmsConfigInfo *));
1116 #endif
1117
1118     return;
1119
1120 invalid:
1121     invalidCommandBlock(pRI);
1122     return;
1123 }
1124
1125 static void dispatchRilCdmaSmsWriteArgs(Parcel &p, RequestInfo *pRI) {
1126     RIL_CDMA_SMS_WriteArgs rcsw;
1127     int32_t  t;
1128     uint32_t ut;
1129     uint8_t  uct;
1130     status_t status;
1131     int32_t  digitCount;
1132
1133     memset(&rcsw, 0, sizeof(rcsw));
1134
1135     status = p.readInt32(&t);
1136     rcsw.status = t;
1137
1138     status = p.readInt32(&t);
1139     rcsw.message.uTeleserviceID = (int) t;
1140
1141     status = p.read(&uct,sizeof(uct));
1142     rcsw.message.bIsServicePresent = (uint8_t) uct;
1143
1144     status = p.readInt32(&t);
1145     rcsw.message.uServicecategory = (int) t;
1146
1147     status = p.readInt32(&t);
1148     rcsw.message.sAddress.digit_mode = (RIL_CDMA_SMS_DigitMode) t;
1149
1150     status = p.readInt32(&t);
1151     rcsw.message.sAddress.number_mode = (RIL_CDMA_SMS_NumberMode) t;
1152
1153     status = p.readInt32(&t);
1154     rcsw.message.sAddress.number_type = (RIL_CDMA_SMS_NumberType) t;
1155
1156     status = p.readInt32(&t);
1157     rcsw.message.sAddress.number_plan = (RIL_CDMA_SMS_NumberPlan) t;
1158
1159     status = p.read(&uct,sizeof(uct));
1160     rcsw.message.sAddress.number_of_digits = (uint8_t) uct;
1161
1162     for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_ADDRESS_MAX; digitCount ++) {
1163         status = p.read(&uct,sizeof(uct));
1164         rcsw.message.sAddress.digits[digitCount] = (uint8_t) uct;
1165     }
1166
1167     status = p.readInt32(&t);
1168     rcsw.message.sSubAddress.subaddressType = (RIL_CDMA_SMS_SubaddressType) t;
1169
1170     status = p.read(&uct,sizeof(uct));
1171     rcsw.message.sSubAddress.odd = (uint8_t) uct;
1172
1173     status = p.read(&uct,sizeof(uct));
1174     rcsw.message.sSubAddress.number_of_digits = (uint8_t) uct;
1175
1176     for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_SUBADDRESS_MAX; digitCount ++) {
1177         status = p.read(&uct,sizeof(uct));
1178         rcsw.message.sSubAddress.digits[digitCount] = (uint8_t) uct;
1179     }
1180
1181     status = p.readInt32(&t);
1182     rcsw.message.uBearerDataLen = (int) t;
1183
1184     for(digitCount = 0 ; digitCount < RIL_CDMA_SMS_BEARER_DATA_MAX; digitCount ++) {
1185         status = p.read(&uct, sizeof(uct));
1186         rcsw.message.aBearerData[digitCount] = (uint8_t) uct;
1187     }
1188
1189     if (status != NO_ERROR) {
1190         goto invalid;
1191     }
1192
1193     startRequest;
1194     appendPrintBuf("%sstatus=%d, message.uTeleserviceID=%d, message.bIsServicePresent=%d, \
1195             message.uServicecategory=%d, message.sAddress.digit_mode=%d, \
1196             message.sAddress.number_mode=%d, \
1197             message.sAddress.number_type=%d, ",
1198             printBuf, rcsw.status, rcsw.message.uTeleserviceID, rcsw.message.bIsServicePresent,
1199             rcsw.message.uServicecategory, rcsw.message.sAddress.digit_mode,
1200             rcsw.message.sAddress.number_mode,
1201             rcsw.message.sAddress.number_type);
1202     closeRequest;
1203
1204     printRequest(pRI->token, pRI->pCI->requestNumber);
1205
1206     s_callbacks.onRequest(pRI->pCI->requestNumber, &rcsw, sizeof(rcsw),pRI);
1207
1208 #ifdef MEMSET_FREED
1209     memset(&rcsw, 0, sizeof(rcsw));
1210 #endif
1211
1212     return;
1213
1214 invalid:
1215     invalidCommandBlock(pRI);
1216     return;
1217
1218 }
1219
1220 // For backwards compatibility in RIL_REQUEST_SETUP_DATA_CALL.
1221 // Version 4 of the RIL interface adds a new PDP type parameter to support
1222 // IPv6 and dual-stack PDP contexts. When dealing with a previous version of
1223 // RIL, remove the parameter from the request.
1224 static void dispatchDataCall(Parcel& p, RequestInfo *pRI) {
1225     // In RIL v3, REQUEST_SETUP_DATA_CALL takes 6 parameters.
1226     const int numParamsRilV3 = 6;
1227
1228     // The first bytes of the RIL parcel contain the request number and the
1229     // serial number - see processCommandBuffer(). Copy them over too.
1230     int pos = p.dataPosition();
1231
1232     int numParams = p.readInt32();
1233     if (s_callbacks.version < 4 && numParams > numParamsRilV3) {
1234       Parcel p2;
1235       p2.appendFrom(&p, 0, pos);
1236       p2.writeInt32(numParamsRilV3);
1237       for(int i = 0; i < numParamsRilV3; i++) {
1238         p2.writeString16(p.readString16());
1239       }
1240       p2.setDataPosition(pos);
1241       dispatchStrings(p2, pRI);
1242     } else {
1243       p.setDataPosition(pos);
1244       dispatchStrings(p, pRI);
1245     }
1246 }
1247
1248 // For backwards compatibility with RILs that dont support RIL_REQUEST_VOICE_RADIO_TECH.
1249 // When all RILs handle this request, this function can be removed and
1250 // the request can be sent directly to the RIL using dispatchVoid.
1251 static void dispatchVoiceRadioTech(Parcel& p, RequestInfo *pRI) {
1252     RIL_RadioState state = s_callbacks.onStateRequest();
1253
1254     if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
1255         RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1256     }
1257
1258     // RILs that support RADIO_STATE_ON should support this request.
1259     if (RADIO_STATE_ON == state) {
1260         dispatchVoid(p, pRI);
1261         return;
1262     }
1263
1264     // For Older RILs, that do not support RADIO_STATE_ON, assume that they
1265     // will not support this new request either and decode Voice Radio Technology
1266     // from Radio State
1267     voiceRadioTech = decodeVoiceRadioTechnology(state);
1268
1269     if (voiceRadioTech < 0)
1270         RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
1271     else
1272         RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &voiceRadioTech, sizeof(int));
1273 }
1274
1275 // For backwards compatibility in RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:.
1276 // When all RILs handle this request, this function can be removed and
1277 // the request can be sent directly to the RIL using dispatchVoid.
1278 static void dispatchCdmaSubscriptionSource(Parcel& p, RequestInfo *pRI) {
1279     RIL_RadioState state = s_callbacks.onStateRequest();
1280
1281     if ((RADIO_STATE_UNAVAILABLE == state) || (RADIO_STATE_OFF == state)) {
1282         RIL_onRequestComplete(pRI, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1283     }
1284
1285     // RILs that support RADIO_STATE_ON should support this request.
1286     if (RADIO_STATE_ON == state) {
1287         dispatchVoid(p, pRI);
1288         return;
1289     }
1290
1291     // For Older RILs, that do not support RADIO_STATE_ON, assume that they
1292     // will not support this new request either and decode CDMA Subscription Source
1293     // from Radio State
1294     cdmaSubscriptionSource = decodeCdmaSubscriptionSource(state);
1295
1296     if (cdmaSubscriptionSource < 0)
1297         RIL_onRequestComplete(pRI, RIL_E_GENERIC_FAILURE, NULL, 0);
1298     else
1299         RIL_onRequestComplete(pRI, RIL_E_SUCCESS, &cdmaSubscriptionSource, sizeof(int));
1300 }
1301
1302 static int
1303 blockingWrite(int fd, const void *buffer, size_t len) {
1304     size_t writeOffset = 0;
1305     const uint8_t *toWrite;
1306
1307     toWrite = (const uint8_t *)buffer;
1308
1309     while (writeOffset < len) {
1310         ssize_t written;
1311         do {
1312             written = write (fd, toWrite + writeOffset,
1313                                 len - writeOffset);
1314         } while (written < 0 && errno == EINTR);
1315
1316         if (written >= 0) {
1317             writeOffset += written;
1318         } else {   // written < 0
1319             ALOGE ("RIL Response: unexpected error on write errno:%d", errno);
1320             close(fd);
1321             return -1;
1322         }
1323     }
1324
1325     return 0;
1326 }
1327
1328 static int
1329 sendResponseRaw (const void *data, size_t dataSize) {
1330     int fd = s_fdCommand;
1331     int ret;
1332     uint32_t header;
1333
1334     if (s_fdCommand < 0) {
1335         return -1;
1336     }
1337
1338     if (dataSize > MAX_COMMAND_BYTES) {
1339         ALOGE("RIL: packet larger than %u (%u)",
1340                 MAX_COMMAND_BYTES, (unsigned int )dataSize);
1341
1342         return -1;
1343     }
1344
1345     pthread_mutex_lock(&s_writeMutex);
1346
1347     header = htonl(dataSize);
1348
1349     ret = blockingWrite(fd, (void *)&header, sizeof(header));
1350
1351     if (ret < 0) {
1352         pthread_mutex_unlock(&s_writeMutex);
1353         return ret;
1354     }
1355
1356     ret = blockingWrite(fd, data, dataSize);
1357
1358     if (ret < 0) {
1359         pthread_mutex_unlock(&s_writeMutex);
1360         return ret;
1361     }
1362
1363     pthread_mutex_unlock(&s_writeMutex);
1364
1365     return 0;
1366 }
1367
1368 static int
1369 sendResponse (Parcel &p) {
1370     printResponse;
1371     return sendResponseRaw(p.data(), p.dataSize());
1372 }
1373
1374 /** response is an int* pointing to an array of ints*/
1375
1376 static int
1377 responseInts(Parcel &p, void *response, size_t responselen) {
1378     int numInts;
1379
1380     if (response == NULL && responselen != 0) {
1381         ALOGE("invalid response: NULL");
1382         return RIL_ERRNO_INVALID_RESPONSE;
1383     }
1384     if (responselen % sizeof(int) != 0) {
1385         ALOGE("invalid response length %d expected multiple of %d\n",
1386             (int)responselen, (int)sizeof(int));
1387         return RIL_ERRNO_INVALID_RESPONSE;
1388     }
1389
1390     int *p_int = (int *) response;
1391
1392     numInts = responselen / sizeof(int *);
1393     p.writeInt32 (numInts);
1394
1395     /* each int*/
1396     startResponse;
1397     for (int i = 0 ; i < numInts ; i++) {
1398         appendPrintBuf("%s%d,", printBuf, p_int[i]);
1399         p.writeInt32(p_int[i]);
1400     }
1401     removeLastChar;
1402     closeResponse;
1403
1404     return 0;
1405 }
1406
1407 /** response is a char **, pointing to an array of char *'s
1408     The parcel will begin with the version */
1409 static int responseStringsWithVersion(int version, Parcel &p, void *response, size_t responselen) {
1410     p.writeInt32(version);
1411     return responseStrings(p, response, responselen);
1412 }
1413
1414 /** response is a char **, pointing to an array of char *'s */
1415 static int responseStrings(Parcel &p, void *response, size_t responselen) {
1416     int numStrings;
1417
1418     if (response == NULL && responselen != 0) {
1419         ALOGE("invalid response: NULL");
1420         return RIL_ERRNO_INVALID_RESPONSE;
1421     }
1422     if (responselen % sizeof(char *) != 0) {
1423         ALOGE("invalid response length %d expected multiple of %d\n",
1424             (int)responselen, (int)sizeof(char *));
1425         return RIL_ERRNO_INVALID_RESPONSE;
1426     }
1427
1428     if (response == NULL) {
1429         p.writeInt32 (0);
1430     } else {
1431         char **p_cur = (char **) response;
1432
1433         numStrings = responselen / sizeof(char *);
1434         p.writeInt32 (numStrings);
1435
1436         /* each string*/
1437         startResponse;
1438         for (int i = 0 ; i < numStrings ; i++) {
1439             appendPrintBuf("%s%s,", printBuf, (char*)p_cur[i]);
1440             writeStringToParcel (p, p_cur[i]);
1441         }
1442         removeLastChar;
1443         closeResponse;
1444     }
1445     return 0;
1446 }
1447
1448
1449 /**
1450  * NULL strings are accepted
1451  * FIXME currently ignores responselen
1452  */
1453 static int responseString(Parcel &p, void *response, size_t responselen) {
1454     /* one string only */
1455     startResponse;
1456     appendPrintBuf("%s%s", printBuf, (char*)response);
1457     closeResponse;
1458
1459     writeStringToParcel(p, (const char *)response);
1460
1461     return 0;
1462 }
1463
1464 static int responseVoid(Parcel &p, void *response, size_t responselen) {
1465     startResponse;
1466     removeLastChar;
1467     return 0;
1468 }
1469
1470 static int responseCallList(Parcel &p, void *response, size_t responselen) {
1471     int num;
1472
1473     if (response == NULL && responselen != 0) {
1474         ALOGE("invalid response: NULL");
1475         return RIL_ERRNO_INVALID_RESPONSE;
1476     }
1477
1478     if (responselen % sizeof (RIL_Call *) != 0) {
1479         ALOGE("invalid response length %d expected multiple of %d\n",
1480             (int)responselen, (int)sizeof (RIL_Call *));
1481         return RIL_ERRNO_INVALID_RESPONSE;
1482     }
1483
1484     startResponse;
1485     /* number of call info's */
1486     num = responselen / sizeof(RIL_Call *);
1487     p.writeInt32(num);
1488
1489     for (int i = 0 ; i < num ; i++) {
1490         RIL_Call *p_cur = ((RIL_Call **) response)[i];
1491         /* each call info */
1492         p.writeInt32(p_cur->state);
1493         p.writeInt32(p_cur->index);
1494         p.writeInt32(p_cur->toa);
1495         p.writeInt32(p_cur->isMpty);
1496         p.writeInt32(p_cur->isMT);
1497         p.writeInt32(p_cur->als);
1498         p.writeInt32(p_cur->isVoice);
1499         p.writeInt32(p_cur->isVoicePrivacy);
1500         writeStringToParcel(p, p_cur->number);
1501         p.writeInt32(p_cur->numberPresentation);
1502         writeStringToParcel(p, p_cur->name);
1503         p.writeInt32(p_cur->namePresentation);
1504         // Remove when partners upgrade to version 3
1505         if ((s_callbacks.version < 3) || (p_cur->uusInfo == NULL || p_cur->uusInfo->uusData == NULL)) {
1506             p.writeInt32(0); /* UUS Information is absent */
1507         } else {
1508             RIL_UUS_Info *uusInfo = p_cur->uusInfo;
1509             p.writeInt32(1); /* UUS Information is present */
1510             p.writeInt32(uusInfo->uusType);
1511             p.writeInt32(uusInfo->uusDcs);
1512             p.writeInt32(uusInfo->uusLength);
1513             p.write(uusInfo->uusData, uusInfo->uusLength);
1514         }
1515         appendPrintBuf("%s[id=%d,%s,toa=%d,",
1516             printBuf,
1517             p_cur->index,
1518             callStateToString(p_cur->state),
1519             p_cur->toa);
1520         appendPrintBuf("%s%s,%s,als=%d,%s,%s,",
1521             printBuf,
1522             (p_cur->isMpty)?"conf":"norm",
1523             (p_cur->isMT)?"mt":"mo",
1524             p_cur->als,
1525             (p_cur->isVoice)?"voc":"nonvoc",
1526             (p_cur->isVoicePrivacy)?"evp":"noevp");
1527         appendPrintBuf("%s%s,cli=%d,name='%s',%d]",
1528             printBuf,
1529             p_cur->number,
1530             p_cur->numberPresentation,
1531             p_cur->name,
1532             p_cur->namePresentation);
1533     }
1534     removeLastChar;
1535     closeResponse;
1536
1537     return 0;
1538 }
1539
1540 static int responseSMS(Parcel &p, void *response, size_t responselen) {
1541     if (response == NULL) {
1542         ALOGE("invalid response: NULL");
1543         return RIL_ERRNO_INVALID_RESPONSE;
1544     }
1545
1546     if (responselen != sizeof (RIL_SMS_Response) ) {
1547         ALOGE("invalid response length %d expected %d",
1548                 (int)responselen, (int)sizeof (RIL_SMS_Response));
1549         return RIL_ERRNO_INVALID_RESPONSE;
1550     }
1551
1552     RIL_SMS_Response *p_cur = (RIL_SMS_Response *) response;
1553
1554     p.writeInt32(p_cur->messageRef);
1555     writeStringToParcel(p, p_cur->ackPDU);
1556     p.writeInt32(p_cur->errorCode);
1557
1558     startResponse;
1559     appendPrintBuf("%s%d,%s,%d", printBuf, p_cur->messageRef,
1560         (char*)p_cur->ackPDU, p_cur->errorCode);
1561     closeResponse;
1562
1563     return 0;
1564 }
1565
1566 static int responseDataCallListV4(Parcel &p, void *response, size_t responselen)
1567 {
1568     if (response == NULL && responselen != 0) {
1569         ALOGE("invalid response: NULL");
1570         return RIL_ERRNO_INVALID_RESPONSE;
1571     }
1572
1573     if (responselen % sizeof(RIL_Data_Call_Response_v4) != 0) {
1574         ALOGE("invalid response length %d expected multiple of %d",
1575                 (int)responselen, (int)sizeof(RIL_Data_Call_Response_v4));
1576         return RIL_ERRNO_INVALID_RESPONSE;
1577     }
1578
1579     int num = responselen / sizeof(RIL_Data_Call_Response_v4);
1580     p.writeInt32(num);
1581
1582     RIL_Data_Call_Response_v4 *p_cur = (RIL_Data_Call_Response_v4 *) response;
1583     startResponse;
1584     int i;
1585     for (i = 0; i < num; i++) {
1586         p.writeInt32(p_cur[i].cid);
1587         p.writeInt32(p_cur[i].active);
1588         writeStringToParcel(p, p_cur[i].type);
1589         // apn is not used, so don't send.
1590         writeStringToParcel(p, p_cur[i].address);
1591         appendPrintBuf("%s[cid=%d,%s,%s,%s],", printBuf,
1592             p_cur[i].cid,
1593             (p_cur[i].active==0)?"down":"up",
1594             (char*)p_cur[i].type,
1595             (char*)p_cur[i].address);
1596     }
1597     removeLastChar;
1598     closeResponse;
1599
1600     return 0;
1601 }
1602
1603 static int responseDataCallList(Parcel &p, void *response, size_t responselen)
1604 {
1605     // Write version
1606     p.writeInt32(s_callbacks.version);
1607
1608     if (s_callbacks.version < 5) {
1609         return responseDataCallListV4(p, response, responselen);
1610     } else {
1611         if (response == NULL && responselen != 0) {
1612             ALOGE("invalid response: NULL");
1613             return RIL_ERRNO_INVALID_RESPONSE;
1614         }
1615
1616         if (responselen % sizeof(RIL_Data_Call_Response_v6) != 0) {
1617             ALOGE("invalid response length %d expected multiple of %d",
1618                     (int)responselen, (int)sizeof(RIL_Data_Call_Response_v6));
1619             return RIL_ERRNO_INVALID_RESPONSE;
1620         }
1621
1622         int num = responselen / sizeof(RIL_Data_Call_Response_v6);
1623         p.writeInt32(num);
1624
1625         RIL_Data_Call_Response_v6 *p_cur = (RIL_Data_Call_Response_v6 *) response;
1626         startResponse;
1627         int i;
1628         for (i = 0; i < num; i++) {
1629             p.writeInt32((int)p_cur[i].status);
1630             p.writeInt32(p_cur[i].suggestedRetryTime);
1631             p.writeInt32(p_cur[i].cid);
1632             p.writeInt32(p_cur[i].active);
1633             writeStringToParcel(p, p_cur[i].type);
1634             writeStringToParcel(p, p_cur[i].ifname);
1635             writeStringToParcel(p, p_cur[i].addresses);
1636             writeStringToParcel(p, p_cur[i].dnses);
1637             writeStringToParcel(p, p_cur[i].gateways);
1638             appendPrintBuf("%s[status=%d,retry=%d,cid=%d,%s,%d,%s,%s,%s],", printBuf,
1639                 p_cur[i].status,
1640                 p_cur[i].suggestedRetryTime,
1641                 p_cur[i].cid,
1642                 (p_cur[i].active==0)?"down":"up",
1643                 (char*)p_cur[i].ifname,
1644                 (char*)p_cur[i].addresses,
1645                 (char*)p_cur[i].dnses,
1646                 (char*)p_cur[i].gateways);
1647         }
1648         removeLastChar;
1649         closeResponse;
1650     }
1651
1652     return 0;
1653 }
1654
1655 static int responseSetupDataCall(Parcel &p, void *response, size_t responselen)
1656 {
1657     if (s_callbacks.version < 5) {
1658         return responseStringsWithVersion(s_callbacks.version, p, response, responselen);
1659     } else {
1660         return responseDataCallList(p, response, responselen);
1661     }
1662 }
1663
1664 static int responseRaw(Parcel &p, void *response, size_t responselen) {
1665     if (response == NULL && responselen != 0) {
1666         ALOGE("invalid response: NULL with responselen != 0");
1667         return RIL_ERRNO_INVALID_RESPONSE;
1668     }
1669
1670     // The java code reads -1 size as null byte array
1671     if (response == NULL) {
1672         p.writeInt32(-1);
1673     } else {
1674         p.writeInt32(responselen);
1675         p.write(response, responselen);
1676     }
1677
1678     return 0;
1679 }
1680
1681
1682 static int responseSIM_IO(Parcel &p, void *response, size_t responselen) {
1683     if (response == NULL) {
1684         ALOGE("invalid response: NULL");
1685         return RIL_ERRNO_INVALID_RESPONSE;
1686     }
1687
1688     if (responselen != sizeof (RIL_SIM_IO_Response) ) {
1689         ALOGE("invalid response length was %d expected %d",
1690                 (int)responselen, (int)sizeof (RIL_SIM_IO_Response));
1691         return RIL_ERRNO_INVALID_RESPONSE;
1692     }
1693
1694     RIL_SIM_IO_Response *p_cur = (RIL_SIM_IO_Response *) response;
1695     p.writeInt32(p_cur->sw1);
1696     p.writeInt32(p_cur->sw2);
1697     writeStringToParcel(p, p_cur->simResponse);
1698
1699     startResponse;
1700     appendPrintBuf("%ssw1=0x%X,sw2=0x%X,%s", printBuf, p_cur->sw1, p_cur->sw2,
1701         (char*)p_cur->simResponse);
1702     closeResponse;
1703
1704
1705     return 0;
1706 }
1707
1708 static int responseCallForwards(Parcel &p, void *response, size_t responselen) {
1709     int num;
1710
1711     if (response == NULL && responselen != 0) {
1712         ALOGE("invalid response: NULL");
1713         return RIL_ERRNO_INVALID_RESPONSE;
1714     }
1715
1716     if (responselen % sizeof(RIL_CallForwardInfo *) != 0) {
1717         ALOGE("invalid response length %d expected multiple of %d",
1718                 (int)responselen, (int)sizeof(RIL_CallForwardInfo *));
1719         return RIL_ERRNO_INVALID_RESPONSE;
1720     }
1721
1722     /* number of call info's */
1723     num = responselen / sizeof(RIL_CallForwardInfo *);
1724     p.writeInt32(num);
1725
1726     startResponse;
1727     for (int i = 0 ; i < num ; i++) {
1728         RIL_CallForwardInfo *p_cur = ((RIL_CallForwardInfo **) response)[i];
1729
1730         p.writeInt32(p_cur->status);
1731         p.writeInt32(p_cur->reason);
1732         p.writeInt32(p_cur->serviceClass);
1733         p.writeInt32(p_cur->toa);
1734         writeStringToParcel(p, p_cur->number);
1735         p.writeInt32(p_cur->timeSeconds);
1736         appendPrintBuf("%s[%s,reason=%d,cls=%d,toa=%d,%s,tout=%d],", printBuf,
1737             (p_cur->status==1)?"enable":"disable",
1738             p_cur->reason, p_cur->serviceClass, p_cur->toa,
1739             (char*)p_cur->number,
1740             p_cur->timeSeconds);
1741     }
1742     removeLastChar;
1743     closeResponse;
1744
1745     return 0;
1746 }
1747
1748 static int responseSsn(Parcel &p, void *response, size_t responselen) {
1749     if (response == NULL) {
1750         ALOGE("invalid response: NULL");
1751         return RIL_ERRNO_INVALID_RESPONSE;
1752     }
1753
1754     if (responselen != sizeof(RIL_SuppSvcNotification)) {
1755         ALOGE("invalid response length was %d expected %d",
1756                 (int)responselen, (int)sizeof (RIL_SuppSvcNotification));
1757         return RIL_ERRNO_INVALID_RESPONSE;
1758     }
1759
1760     RIL_SuppSvcNotification *p_cur = (RIL_SuppSvcNotification *) response;
1761     p.writeInt32(p_cur->notificationType);
1762     p.writeInt32(p_cur->code);
1763     p.writeInt32(p_cur->index);
1764     p.writeInt32(p_cur->type);
1765     writeStringToParcel(p, p_cur->number);
1766
1767     startResponse;
1768     appendPrintBuf("%s%s,code=%d,id=%d,type=%d,%s", printBuf,
1769         (p_cur->notificationType==0)?"mo":"mt",
1770          p_cur->code, p_cur->index, p_cur->type,
1771         (char*)p_cur->number);
1772     closeResponse;
1773
1774     return 0;
1775 }
1776
1777 static int responseCellList(Parcel &p, void *response, size_t responselen) {
1778     int num;
1779
1780     if (response == NULL && responselen != 0) {
1781         ALOGE("invalid response: NULL");
1782         return RIL_ERRNO_INVALID_RESPONSE;
1783     }
1784
1785     if (responselen % sizeof (RIL_NeighboringCell *) != 0) {
1786         ALOGE("invalid response length %d expected multiple of %d\n",
1787             (int)responselen, (int)sizeof (RIL_NeighboringCell *));
1788         return RIL_ERRNO_INVALID_RESPONSE;
1789     }
1790
1791     startResponse;
1792     /* number of records */
1793     num = responselen / sizeof(RIL_NeighboringCell *);
1794     p.writeInt32(num);
1795
1796     for (int i = 0 ; i < num ; i++) {
1797         RIL_NeighboringCell *p_cur = ((RIL_NeighboringCell **) response)[i];
1798
1799         p.writeInt32(p_cur->rssi);
1800         writeStringToParcel (p, p_cur->cid);
1801
1802         appendPrintBuf("%s[cid=%s,rssi=%d],", printBuf,
1803             p_cur->cid, p_cur->rssi);
1804     }
1805     removeLastChar;
1806     closeResponse;
1807
1808     return 0;
1809 }
1810
1811 /**
1812  * Marshall the signalInfoRecord into the parcel if it exists.
1813  */
1814 static void marshallSignalInfoRecord(Parcel &p,
1815             RIL_CDMA_SignalInfoRecord &p_signalInfoRecord) {
1816     p.writeInt32(p_signalInfoRecord.isPresent);
1817     p.writeInt32(p_signalInfoRecord.signalType);
1818     p.writeInt32(p_signalInfoRecord.alertPitch);
1819     p.writeInt32(p_signalInfoRecord.signal);
1820 }
1821
1822 static int responseCdmaInformationRecords(Parcel &p,
1823             void *response, size_t responselen) {
1824     int num;
1825     char* string8 = NULL;
1826     int buffer_lenght;
1827     RIL_CDMA_InformationRecord *infoRec;
1828
1829     if (response == NULL && responselen != 0) {
1830         ALOGE("invalid response: NULL");
1831         return RIL_ERRNO_INVALID_RESPONSE;
1832     }
1833
1834     if (responselen != sizeof (RIL_CDMA_InformationRecords)) {
1835         ALOGE("invalid response length %d expected multiple of %d\n",
1836             (int)responselen, (int)sizeof (RIL_CDMA_InformationRecords *));
1837         return RIL_ERRNO_INVALID_RESPONSE;
1838     }
1839
1840     RIL_CDMA_InformationRecords *p_cur =
1841                              (RIL_CDMA_InformationRecords *) response;
1842     num = MIN(p_cur->numberOfInfoRecs, RIL_CDMA_MAX_NUMBER_OF_INFO_RECS);
1843
1844     startResponse;
1845     p.writeInt32(num);
1846
1847     for (int i = 0 ; i < num ; i++) {
1848         infoRec = &p_cur->infoRec[i];
1849         p.writeInt32(infoRec->name);
1850         switch (infoRec->name) {
1851             case RIL_CDMA_DISPLAY_INFO_REC:
1852             case RIL_CDMA_EXTENDED_DISPLAY_INFO_REC:
1853                 if (infoRec->rec.display.alpha_len >
1854                                          CDMA_ALPHA_INFO_BUFFER_LENGTH) {
1855                     ALOGE("invalid display info response length %d \
1856                           expected not more than %d\n",
1857                          (int)infoRec->rec.display.alpha_len,
1858                          CDMA_ALPHA_INFO_BUFFER_LENGTH);
1859                     return RIL_ERRNO_INVALID_RESPONSE;
1860                 }
1861                 string8 = (char*) malloc((infoRec->rec.display.alpha_len + 1)
1862                                                              * sizeof(char) );
1863                 for (int i = 0 ; i < infoRec->rec.display.alpha_len ; i++) {
1864                     string8[i] = infoRec->rec.display.alpha_buf[i];
1865                 }
1866                 string8[(int)infoRec->rec.display.alpha_len] = '\0';
1867                 writeStringToParcel(p, (const char*)string8);
1868                 free(string8);
1869                 string8 = NULL;
1870                 break;
1871             case RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC:
1872             case RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC:
1873             case RIL_CDMA_CONNECTED_NUMBER_INFO_REC:
1874                 if (infoRec->rec.number.len > CDMA_NUMBER_INFO_BUFFER_LENGTH) {
1875                     ALOGE("invalid display info response length %d \
1876                           expected not more than %d\n",
1877                          (int)infoRec->rec.number.len,
1878                          CDMA_NUMBER_INFO_BUFFER_LENGTH);
1879                     return RIL_ERRNO_INVALID_RESPONSE;
1880                 }
1881                 string8 = (char*) malloc((infoRec->rec.number.len + 1)
1882                                                              * sizeof(char) );
1883                 for (int i = 0 ; i < infoRec->rec.number.len; i++) {
1884                     string8[i] = infoRec->rec.number.buf[i];
1885                 }
1886                 string8[(int)infoRec->rec.number.len] = '\0';
1887                 writeStringToParcel(p, (const char*)string8);
1888                 free(string8);
1889                 string8 = NULL;
1890                 p.writeInt32(infoRec->rec.number.number_type);
1891                 p.writeInt32(infoRec->rec.number.number_plan);
1892                 p.writeInt32(infoRec->rec.number.pi);
1893                 p.writeInt32(infoRec->rec.number.si);
1894                 break;
1895             case RIL_CDMA_SIGNAL_INFO_REC:
1896                 p.writeInt32(infoRec->rec.signal.isPresent);
1897                 p.writeInt32(infoRec->rec.signal.signalType);
1898                 p.writeInt32(infoRec->rec.signal.alertPitch);
1899                 p.writeInt32(infoRec->rec.signal.signal);
1900
1901                 appendPrintBuf("%sisPresent=%X, signalType=%X, \
1902                                 alertPitch=%X, signal=%X, ",
1903                    printBuf, (int)infoRec->rec.signal.isPresent,
1904                    (int)infoRec->rec.signal.signalType,
1905                    (int)infoRec->rec.signal.alertPitch,
1906                    (int)infoRec->rec.signal.signal);
1907                 removeLastChar;
1908                 break;
1909             case RIL_CDMA_REDIRECTING_NUMBER_INFO_REC:
1910                 if (infoRec->rec.redir.redirectingNumber.len >
1911                                               CDMA_NUMBER_INFO_BUFFER_LENGTH) {
1912                     ALOGE("invalid display info response length %d \
1913                           expected not more than %d\n",
1914                          (int)infoRec->rec.redir.redirectingNumber.len,
1915                          CDMA_NUMBER_INFO_BUFFER_LENGTH);
1916                     return RIL_ERRNO_INVALID_RESPONSE;
1917                 }
1918                 string8 = (char*) malloc((infoRec->rec.redir.redirectingNumber
1919                                           .len + 1) * sizeof(char) );
1920                 for (int i = 0;
1921                          i < infoRec->rec.redir.redirectingNumber.len;
1922                          i++) {
1923                     string8[i] = infoRec->rec.redir.redirectingNumber.buf[i];
1924                 }
1925                 string8[(int)infoRec->rec.redir.redirectingNumber.len] = '\0';
1926                 writeStringToParcel(p, (const char*)string8);
1927                 free(string8);
1928                 string8 = NULL;
1929                 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_type);
1930                 p.writeInt32(infoRec->rec.redir.redirectingNumber.number_plan);
1931                 p.writeInt32(infoRec->rec.redir.redirectingNumber.pi);
1932                 p.writeInt32(infoRec->rec.redir.redirectingNumber.si);
1933                 p.writeInt32(infoRec->rec.redir.redirectingReason);
1934                 break;
1935             case RIL_CDMA_LINE_CONTROL_INFO_REC:
1936                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPolarityIncluded);
1937                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlToggle);
1938                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlReverse);
1939                 p.writeInt32(infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1940
1941                 appendPrintBuf("%slineCtrlPolarityIncluded=%d, \
1942                                 lineCtrlToggle=%d, lineCtrlReverse=%d, \
1943                                 lineCtrlPowerDenial=%d, ", printBuf,
1944                        (int)infoRec->rec.lineCtrl.lineCtrlPolarityIncluded,
1945                        (int)infoRec->rec.lineCtrl.lineCtrlToggle,
1946                        (int)infoRec->rec.lineCtrl.lineCtrlReverse,
1947                        (int)infoRec->rec.lineCtrl.lineCtrlPowerDenial);
1948                 removeLastChar;
1949                 break;
1950             case RIL_CDMA_T53_CLIR_INFO_REC:
1951                 p.writeInt32((int)(infoRec->rec.clir.cause));
1952
1953                 appendPrintBuf("%scause%d", printBuf, infoRec->rec.clir.cause);
1954                 removeLastChar;
1955                 break;
1956             case RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC:
1957                 p.writeInt32(infoRec->rec.audioCtrl.upLink);
1958                 p.writeInt32(infoRec->rec.audioCtrl.downLink);
1959
1960                 appendPrintBuf("%supLink=%d, downLink=%d, ", printBuf,
1961                         infoRec->rec.audioCtrl.upLink,
1962                         infoRec->rec.audioCtrl.downLink);
1963                 removeLastChar;
1964                 break;
1965             case RIL_CDMA_T53_RELEASE_INFO_REC:
1966                 // TODO(Moto): See David Krause, he has the answer:)
1967                 ALOGE("RIL_CDMA_T53_RELEASE_INFO_REC: return INVALID_RESPONSE");
1968                 return RIL_ERRNO_INVALID_RESPONSE;
1969             default:
1970                 ALOGE("Incorrect name value");
1971                 return RIL_ERRNO_INVALID_RESPONSE;
1972         }
1973     }
1974     closeResponse;
1975
1976     return 0;
1977 }
1978
1979 static int responseRilSignalStrength(Parcel &p,
1980                     void *response, size_t responselen) {
1981     if (response == NULL && responselen != 0) {
1982         ALOGE("invalid response: NULL");
1983         return RIL_ERRNO_INVALID_RESPONSE;
1984     }
1985
1986     if (responselen >= sizeof (RIL_SignalStrength_v5)) {
1987         RIL_SignalStrength_v6 *p_cur = ((RIL_SignalStrength_v6 *) response);
1988
1989         p.writeInt32(p_cur->GW_SignalStrength.signalStrength);
1990         p.writeInt32(p_cur->GW_SignalStrength.bitErrorRate);
1991         p.writeInt32(p_cur->CDMA_SignalStrength.dbm);
1992         p.writeInt32(p_cur->CDMA_SignalStrength.ecio);
1993         p.writeInt32(p_cur->EVDO_SignalStrength.dbm);
1994         p.writeInt32(p_cur->EVDO_SignalStrength.ecio);
1995         p.writeInt32(p_cur->EVDO_SignalStrength.signalNoiseRatio);
1996         if (responselen >= sizeof (RIL_SignalStrength_v6)) {
1997             p.writeInt32(p_cur->LTE_SignalStrength.signalStrength);
1998             p.writeInt32(p_cur->LTE_SignalStrength.rsrp);
1999             p.writeInt32(p_cur->LTE_SignalStrength.rsrq);
2000             p.writeInt32(p_cur->LTE_SignalStrength.rssnr);
2001             p.writeInt32(p_cur->LTE_SignalStrength.cqi);
2002         } else {
2003             memset(&p_cur->LTE_SignalStrength, sizeof (RIL_LTE_SignalStrength), 0);
2004         }
2005
2006         startResponse;
2007         appendPrintBuf("%s[signalStrength=%d,bitErrorRate=%d,\
2008                 CDMA_SS.dbm=%d,CDMA_SSecio=%d,\
2009                 EVDO_SS.dbm=%d,EVDO_SS.ecio=%d,\
2010                 EVDO_SS.signalNoiseRatio=%d,\
2011                 LTE_SS.signalStrength=%d,LTE_SS.rsrp=%d,LTE_SS.rsrq=%d,\
2012                 LTE_SS.rssnr=%d,LTE_SS.cqi=%d]",
2013                 printBuf,
2014                 p_cur->GW_SignalStrength.signalStrength,
2015                 p_cur->GW_SignalStrength.bitErrorRate,
2016                 p_cur->CDMA_SignalStrength.dbm,
2017                 p_cur->CDMA_SignalStrength.ecio,
2018                 p_cur->EVDO_SignalStrength.dbm,
2019                 p_cur->EVDO_SignalStrength.ecio,
2020                 p_cur->EVDO_SignalStrength.signalNoiseRatio,
2021                 p_cur->LTE_SignalStrength.signalStrength,
2022                 p_cur->LTE_SignalStrength.rsrp,
2023                 p_cur->LTE_SignalStrength.rsrq,
2024                 p_cur->LTE_SignalStrength.rssnr,
2025                 p_cur->LTE_SignalStrength.cqi);
2026         closeResponse;
2027
2028     } else {
2029         ALOGE("invalid response length");
2030         return RIL_ERRNO_INVALID_RESPONSE;
2031     }
2032
2033     return 0;
2034 }
2035
2036 static int responseCallRing(Parcel &p, void *response, size_t responselen) {
2037     if ((response == NULL) || (responselen == 0)) {
2038         return responseVoid(p, response, responselen);
2039     } else {
2040         return responseCdmaSignalInfoRecord(p, response, responselen);
2041     }
2042 }
2043
2044 static int responseCdmaSignalInfoRecord(Parcel &p, void *response, size_t responselen) {
2045     if (response == NULL || responselen == 0) {
2046         ALOGE("invalid response: NULL");
2047         return RIL_ERRNO_INVALID_RESPONSE;
2048     }
2049
2050     if (responselen != sizeof (RIL_CDMA_SignalInfoRecord)) {
2051         ALOGE("invalid response length %d expected sizeof (RIL_CDMA_SignalInfoRecord) of %d\n",
2052             (int)responselen, (int)sizeof (RIL_CDMA_SignalInfoRecord));
2053         return RIL_ERRNO_INVALID_RESPONSE;
2054     }
2055
2056     startResponse;
2057
2058     RIL_CDMA_SignalInfoRecord *p_cur = ((RIL_CDMA_SignalInfoRecord *) response);
2059     marshallSignalInfoRecord(p, *p_cur);
2060
2061     appendPrintBuf("%s[isPresent=%d,signalType=%d,alertPitch=%d\
2062               signal=%d]",
2063               printBuf,
2064               p_cur->isPresent,
2065               p_cur->signalType,
2066               p_cur->alertPitch,
2067               p_cur->signal);
2068
2069     closeResponse;
2070     return 0;
2071 }
2072
2073 static int responseCdmaCallWaiting(Parcel &p, void *response,
2074             size_t responselen) {
2075     if (response == NULL && responselen != 0) {
2076         ALOGE("invalid response: NULL");
2077         return RIL_ERRNO_INVALID_RESPONSE;
2078     }
2079
2080     if (responselen < sizeof(RIL_CDMA_CallWaiting_v6)) {
2081         ALOGW("Upgrade to ril version %d\n", RIL_VERSION);
2082     }
2083
2084     RIL_CDMA_CallWaiting_v6 *p_cur = ((RIL_CDMA_CallWaiting_v6 *) response);
2085
2086     writeStringToParcel(p, p_cur->number);
2087     p.writeInt32(p_cur->numberPresentation);
2088     writeStringToParcel(p, p_cur->name);
2089     marshallSignalInfoRecord(p, p_cur->signalInfoRecord);
2090
2091     if (responselen >= sizeof(RIL_CDMA_CallWaiting_v6)) {
2092         p.writeInt32(p_cur->number_type);
2093         p.writeInt32(p_cur->number_plan);
2094     } else {
2095         p.writeInt32(0);
2096         p.writeInt32(0);
2097     }
2098
2099     startResponse;
2100     appendPrintBuf("%snumber=%s,numberPresentation=%d, name=%s,\
2101             signalInfoRecord[isPresent=%d,signalType=%d,alertPitch=%d\
2102             signal=%d,number_type=%d,number_plan=%d]",
2103             printBuf,
2104             p_cur->number,
2105             p_cur->numberPresentation,
2106             p_cur->name,
2107             p_cur->signalInfoRecord.isPresent,
2108             p_cur->signalInfoRecord.signalType,
2109             p_cur->signalInfoRecord.alertPitch,
2110             p_cur->signalInfoRecord.signal,
2111             p_cur->number_type,
2112             p_cur->number_plan);
2113     closeResponse;
2114
2115     return 0;
2116 }
2117
2118 static int responseSimRefresh(Parcel &p, void *response, size_t responselen) {
2119     if (response == NULL && responselen != 0) {
2120         ALOGE("responseSimRefresh: invalid response: NULL");
2121         return RIL_ERRNO_INVALID_RESPONSE;
2122     }
2123
2124     startResponse;
2125     if (s_callbacks.version == 7) {
2126         RIL_SimRefreshResponse_v7 *p_cur = ((RIL_SimRefreshResponse_v7 *) response);
2127         p.writeInt32(p_cur->result);
2128         p.writeInt32(p_cur->ef_id);
2129         writeStringToParcel(p, p_cur->aid);
2130
2131         appendPrintBuf("%sresult=%d, ef_id=%d, aid=%s",
2132                 printBuf,
2133                 p_cur->result,
2134                 p_cur->ef_id,
2135                 p_cur->aid);
2136     } else {
2137         int *p_cur = ((int *) response);
2138         p.writeInt32(p_cur[0]);
2139         p.writeInt32(p_cur[1]);
2140         writeStringToParcel(p, NULL);
2141
2142         appendPrintBuf("%sresult=%d, ef_id=%d",
2143                 printBuf,
2144                 p_cur[0],
2145                 p_cur[1]);
2146     }
2147     closeResponse;
2148
2149     return 0;
2150 }
2151
2152 static void triggerEvLoop() {
2153     int ret;
2154     if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
2155         /* trigger event loop to wakeup. No reason to do this,
2156          * if we're in the event loop thread */
2157          do {
2158             ret = write (s_fdWakeupWrite, " ", 1);
2159          } while (ret < 0 && errno == EINTR);
2160     }
2161 }
2162
2163 static void rilEventAddWakeup(struct ril_event *ev) {
2164     ril_event_add(ev);
2165     triggerEvLoop();
2166 }
2167
2168 static void sendSimStatusAppInfo(Parcel &p, int num_apps, RIL_AppStatus appStatus[]) {
2169         p.writeInt32(num_apps);
2170         startResponse;
2171         for (int i = 0; i < num_apps; i++) {
2172             p.writeInt32(appStatus[i].app_type);
2173             p.writeInt32(appStatus[i].app_state);
2174             p.writeInt32(appStatus[i].perso_substate);
2175             writeStringToParcel(p, (const char*)(appStatus[i].aid_ptr));
2176             writeStringToParcel(p, (const char*)
2177                                           (appStatus[i].app_label_ptr));
2178             p.writeInt32(appStatus[i].pin1_replaced);
2179             p.writeInt32(appStatus[i].pin1);
2180             p.writeInt32(appStatus[i].pin2);
2181             appendPrintBuf("%s[app_type=%d,app_state=%d,perso_substate=%d,\
2182                     aid_ptr=%s,app_label_ptr=%s,pin1_replaced=%d,pin1=%d,pin2=%d],",
2183                     printBuf,
2184                     appStatus[i].app_type,
2185                     appStatus[i].app_state,
2186                     appStatus[i].perso_substate,
2187                     appStatus[i].aid_ptr,
2188                     appStatus[i].app_label_ptr,
2189                     appStatus[i].pin1_replaced,
2190                     appStatus[i].pin1,
2191                     appStatus[i].pin2);
2192         }
2193         closeResponse;
2194 }
2195
2196 static int responseSimStatus(Parcel &p, void *response, size_t responselen) {
2197     int i;
2198
2199     if (response == NULL && responselen != 0) {
2200         ALOGE("invalid response: NULL");
2201         return RIL_ERRNO_INVALID_RESPONSE;
2202     }
2203
2204     if (responselen == sizeof (RIL_CardStatus_v6)) {
2205         RIL_CardStatus_v6 *p_cur = ((RIL_CardStatus_v6 *) response);
2206
2207         p.writeInt32(p_cur->card_state);
2208         p.writeInt32(p_cur->universal_pin_state);
2209         p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2210         p.writeInt32(p_cur->cdma_subscription_app_index);
2211         p.writeInt32(p_cur->ims_subscription_app_index);
2212
2213         sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
2214     } else if (responselen == sizeof (RIL_CardStatus_v5)) {
2215         RIL_CardStatus_v5 *p_cur = ((RIL_CardStatus_v5 *) response);
2216
2217         p.writeInt32(p_cur->card_state);
2218         p.writeInt32(p_cur->universal_pin_state);
2219         p.writeInt32(p_cur->gsm_umts_subscription_app_index);
2220         p.writeInt32(p_cur->cdma_subscription_app_index);
2221         p.writeInt32(-1);
2222
2223         sendSimStatusAppInfo(p, p_cur->num_applications, p_cur->applications);
2224     } else {
2225         ALOGE("responseSimStatus: A RilCardStatus_v6 or _v5 expected\n");
2226         return RIL_ERRNO_INVALID_RESPONSE;
2227     }
2228
2229     return 0;
2230 }
2231
2232 static int responseGsmBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2233     int num = responselen / sizeof(RIL_GSM_BroadcastSmsConfigInfo *);
2234     p.writeInt32(num);
2235
2236     startResponse;
2237     RIL_GSM_BroadcastSmsConfigInfo **p_cur =
2238                 (RIL_GSM_BroadcastSmsConfigInfo **) response;
2239     for (int i = 0; i < num; i++) {
2240         p.writeInt32(p_cur[i]->fromServiceId);
2241         p.writeInt32(p_cur[i]->toServiceId);
2242         p.writeInt32(p_cur[i]->fromCodeScheme);
2243         p.writeInt32(p_cur[i]->toCodeScheme);
2244         p.writeInt32(p_cur[i]->selected);
2245
2246         appendPrintBuf("%s [%d: fromServiceId=%d, toServiceId=%d, \
2247                 fromCodeScheme=%d, toCodeScheme=%d, selected =%d]",
2248                 printBuf, i, p_cur[i]->fromServiceId, p_cur[i]->toServiceId,
2249                 p_cur[i]->fromCodeScheme, p_cur[i]->toCodeScheme,
2250                 p_cur[i]->selected);
2251     }
2252     closeResponse;
2253
2254     return 0;
2255 }
2256
2257 static int responseCdmaBrSmsCnf(Parcel &p, void *response, size_t responselen) {
2258     RIL_CDMA_BroadcastSmsConfigInfo **p_cur =
2259                (RIL_CDMA_BroadcastSmsConfigInfo **) response;
2260
2261     int num = responselen / sizeof (RIL_CDMA_BroadcastSmsConfigInfo *);
2262     p.writeInt32(num);
2263
2264     startResponse;
2265     for (int i = 0 ; i < num ; i++ ) {
2266         p.writeInt32(p_cur[i]->service_category);
2267         p.writeInt32(p_cur[i]->language);
2268         p.writeInt32(p_cur[i]->selected);
2269
2270         appendPrintBuf("%s [%d: srvice_category=%d, language =%d, \
2271               selected =%d], ",
2272               printBuf, i, p_cur[i]->service_category, p_cur[i]->language,
2273               p_cur[i]->selected);
2274     }
2275     closeResponse;
2276
2277     return 0;
2278 }
2279
2280 static int responseCdmaSms(Parcel &p, void *response, size_t responselen) {
2281     int num;
2282     int digitCount;
2283     int digitLimit;
2284     uint8_t uct;
2285     void* dest;
2286
2287     ALOGD("Inside responseCdmaSms");
2288
2289     if (response == NULL && responselen != 0) {
2290         ALOGE("invalid response: NULL");
2291         return RIL_ERRNO_INVALID_RESPONSE;
2292     }
2293
2294     if (responselen != sizeof(RIL_CDMA_SMS_Message)) {
2295         ALOGE("invalid response length was %d expected %d",
2296                 (int)responselen, (int)sizeof(RIL_CDMA_SMS_Message));
2297         return RIL_ERRNO_INVALID_RESPONSE;
2298     }
2299
2300     RIL_CDMA_SMS_Message *p_cur = (RIL_CDMA_SMS_Message *) response;
2301     p.writeInt32(p_cur->uTeleserviceID);
2302     p.write(&(p_cur->bIsServicePresent),sizeof(uct));
2303     p.writeInt32(p_cur->uServicecategory);
2304     p.writeInt32(p_cur->sAddress.digit_mode);
2305     p.writeInt32(p_cur->sAddress.number_mode);
2306     p.writeInt32(p_cur->sAddress.number_type);
2307     p.writeInt32(p_cur->sAddress.number_plan);
2308     p.write(&(p_cur->sAddress.number_of_digits), sizeof(uct));
2309     digitLimit= MIN((p_cur->sAddress.number_of_digits), RIL_CDMA_SMS_ADDRESS_MAX);
2310     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2311         p.write(&(p_cur->sAddress.digits[digitCount]),sizeof(uct));
2312     }
2313
2314     p.writeInt32(p_cur->sSubAddress.subaddressType);
2315     p.write(&(p_cur->sSubAddress.odd),sizeof(uct));
2316     p.write(&(p_cur->sSubAddress.number_of_digits),sizeof(uct));
2317     digitLimit= MIN((p_cur->sSubAddress.number_of_digits), RIL_CDMA_SMS_SUBADDRESS_MAX);
2318     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2319         p.write(&(p_cur->sSubAddress.digits[digitCount]),sizeof(uct));
2320     }
2321
2322     digitLimit= MIN((p_cur->uBearerDataLen), RIL_CDMA_SMS_BEARER_DATA_MAX);
2323     p.writeInt32(p_cur->uBearerDataLen);
2324     for(digitCount =0 ; digitCount < digitLimit; digitCount ++) {
2325        p.write(&(p_cur->aBearerData[digitCount]), sizeof(uct));
2326     }
2327
2328     startResponse;
2329     appendPrintBuf("%suTeleserviceID=%d, bIsServicePresent=%d, uServicecategory=%d, \
2330             sAddress.digit_mode=%d, sAddress.number_mode=%d, sAddress.number_type=%d, ",
2331             printBuf, p_cur->uTeleserviceID,p_cur->bIsServicePresent,p_cur->uServicecategory,
2332             p_cur->sAddress.digit_mode, p_cur->sAddress.number_mode,p_cur->sAddress.number_type);
2333     closeResponse;
2334
2335     return 0;
2336 }
2337
2338 /**
2339  * A write on the wakeup fd is done just to pop us out of select()
2340  * We empty the buffer here and then ril_event will reset the timers on the
2341  * way back down
2342  */
2343 static void processWakeupCallback(int fd, short flags, void *param) {
2344     char buff[16];
2345     int ret;
2346
2347     ALOGV("processWakeupCallback");
2348
2349     /* empty our wakeup socket out */
2350     do {
2351         ret = read(s_fdWakeupRead, &buff, sizeof(buff));
2352     } while (ret > 0 || (ret < 0 && errno == EINTR));
2353 }
2354
2355 static void onCommandsSocketClosed() {
2356     int ret;
2357     RequestInfo *p_cur;
2358
2359     /* mark pending requests as "cancelled" so we dont report responses */
2360
2361     ret = pthread_mutex_lock(&s_pendingRequestsMutex);
2362     assert (ret == 0);
2363
2364     p_cur = s_pendingRequests;
2365
2366     for (p_cur = s_pendingRequests
2367             ; p_cur != NULL
2368             ; p_cur  = p_cur->p_next
2369     ) {
2370         p_cur->cancelled = 1;
2371     }
2372
2373     ret = pthread_mutex_unlock(&s_pendingRequestsMutex);
2374     assert (ret == 0);
2375 }
2376
2377 static void processCommandsCallback(int fd, short flags, void *param) {
2378     RecordStream *p_rs;
2379     void *p_record;
2380     size_t recordlen;
2381     int ret;
2382
2383     assert(fd == s_fdCommand);
2384
2385     p_rs = (RecordStream *)param;
2386
2387     for (;;) {
2388         /* loop until EAGAIN/EINTR, end of stream, or other error */
2389         ret = record_stream_get_next(p_rs, &p_record, &recordlen);
2390
2391         if (ret == 0 && p_record == NULL) {
2392             /* end-of-stream */
2393             break;
2394         } else if (ret < 0) {
2395             break;
2396         } else if (ret == 0) { /* && p_record != NULL */
2397             processCommandBuffer(p_record, recordlen);
2398         }
2399     }
2400
2401     if (ret == 0 || !(errno == EAGAIN || errno == EINTR)) {
2402         /* fatal error or end-of-stream */
2403         if (ret != 0) {
2404             ALOGE("error on reading command socket errno:%d\n", errno);
2405         } else {
2406             ALOGW("EOS.  Closing command socket.");
2407         }
2408
2409         close(s_fdCommand);
2410         s_fdCommand = -1;
2411
2412         ril_event_del(&s_commands_event);
2413
2414         record_stream_free(p_rs);
2415
2416         /* start listening for new connections again */
2417         rilEventAddWakeup(&s_listen_event);
2418
2419         onCommandsSocketClosed();
2420     }
2421 }
2422
2423
2424 static void onNewCommandConnect() {
2425     // Inform we are connected and the ril version
2426     int rilVer = s_callbacks.version;
2427     RIL_onUnsolicitedResponse(RIL_UNSOL_RIL_CONNECTED,
2428                                     &rilVer, sizeof(rilVer));
2429
2430     // implicit radio state changed
2431     RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
2432                                     NULL, 0);
2433
2434     // Send last NITZ time data, in case it was missed
2435     if (s_lastNITZTimeData != NULL) {
2436         sendResponseRaw(s_lastNITZTimeData, s_lastNITZTimeDataSize);
2437
2438         free(s_lastNITZTimeData);
2439         s_lastNITZTimeData = NULL;
2440     }
2441
2442     // Get version string
2443     if (s_callbacks.getVersion != NULL) {
2444         const char *version;
2445         version = s_callbacks.getVersion();
2446         ALOGI("RIL Daemon version: %s\n", version);
2447
2448         property_set(PROPERTY_RIL_IMPL, version);
2449     } else {
2450         ALOGI("RIL Daemon version: unavailable\n");
2451         property_set(PROPERTY_RIL_IMPL, "unavailable");
2452     }
2453
2454 }
2455
2456 static void listenCallback (int fd, short flags, void *param) {
2457     int ret;
2458     int err;
2459     int is_phone_socket;
2460     RecordStream *p_rs;
2461
2462     struct sockaddr_un peeraddr;
2463     socklen_t socklen = sizeof (peeraddr);
2464
2465     struct ucred creds;
2466     socklen_t szCreds = sizeof(creds);
2467
2468     struct passwd *pwd = NULL;
2469
2470     assert (s_fdCommand < 0);
2471     assert (fd == s_fdListen);
2472
2473     s_fdCommand = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
2474
2475     if (s_fdCommand < 0 ) {
2476         ALOGE("Error on accept() errno:%d", errno);
2477         /* start listening for new connections again */
2478         rilEventAddWakeup(&s_listen_event);
2479               return;
2480     }
2481
2482     /* check the credential of the other side and only accept socket from
2483      * phone process
2484      */
2485     errno = 0;
2486     is_phone_socket = 0;
2487
2488     err = getsockopt(s_fdCommand, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
2489
2490     if (err == 0 && szCreds > 0) {
2491         errno = 0;
2492         pwd = getpwuid(creds.uid);
2493         if (pwd != NULL) {
2494             if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
2495                 is_phone_socket = 1;
2496             } else {
2497                 ALOGE("RILD can't accept socket from process %s", pwd->pw_name);
2498             }
2499         } else {
2500             ALOGE("Error on getpwuid() errno: %d", errno);
2501         }
2502     } else {
2503         ALOGD("Error on getsockopt() errno: %d", errno);
2504     }
2505
2506     if ( !is_phone_socket ) {
2507       ALOGE("RILD must accept socket from %s", PHONE_PROCESS);
2508
2509       close(s_fdCommand);
2510       s_fdCommand = -1;
2511
2512       onCommandsSocketClosed();
2513
2514       /* start listening for new connections again */
2515       rilEventAddWakeup(&s_listen_event);
2516
2517       return;
2518     }
2519
2520     ret = fcntl(s_fdCommand, F_SETFL, O_NONBLOCK);
2521
2522     if (ret < 0) {
2523         ALOGE ("Error setting O_NONBLOCK errno:%d", errno);
2524     }
2525
2526     ALOGI("libril: new connection");
2527
2528     p_rs = record_stream_new(s_fdCommand, MAX_COMMAND_BYTES);
2529
2530     ril_event_set (&s_commands_event, s_fdCommand, 1,
2531         processCommandsCallback, p_rs);
2532
2533     rilEventAddWakeup (&s_commands_event);
2534
2535     onNewCommandConnect();
2536 }
2537
2538 static void freeDebugCallbackArgs(int number, char **args) {
2539     for (int i = 0; i < number; i++) {
2540         if (args[i] != NULL) {
2541             free(args[i]);
2542         }
2543     }
2544     free(args);
2545 }
2546
2547 static void debugCallback (int fd, short flags, void *param) {
2548     int acceptFD, option;
2549     struct sockaddr_un peeraddr;
2550     socklen_t socklen = sizeof (peeraddr);
2551     int data;
2552     unsigned int qxdm_data[6];
2553     const char *deactData[1] = {"1"};
2554     char *actData[1];
2555     RIL_Dial dialData;
2556     int hangupData[1] = {1};
2557     int number;
2558     char **args;
2559
2560     acceptFD = accept (fd,  (sockaddr *) &peeraddr, &socklen);
2561
2562     if (acceptFD < 0) {
2563         ALOGE ("error accepting on debug port: %d\n", errno);
2564         return;
2565     }
2566
2567     if (recv(acceptFD, &number, sizeof(int), 0) != sizeof(int)) {
2568         ALOGE ("error reading on socket: number of Args: \n");
2569         return;
2570     }
2571     args = (char **) malloc(sizeof(char*) * number);
2572
2573     for (int i = 0; i < number; i++) {
2574         int len;
2575         if (recv(acceptFD, &len, sizeof(int), 0) != sizeof(int)) {
2576             ALOGE ("error reading on socket: Len of Args: \n");
2577             freeDebugCallbackArgs(i, args);
2578             return;
2579         }
2580         // +1 for null-term
2581         args[i] = (char *) malloc((sizeof(char) * len) + 1);
2582         if (recv(acceptFD, args[i], sizeof(char) * len, 0)
2583             != (int)sizeof(char) * len) {
2584             ALOGE ("error reading on socket: Args[%d] \n", i);
2585             freeDebugCallbackArgs(i, args);
2586             return;
2587         }
2588         char * buf = args[i];
2589         buf[len] = 0;
2590     }
2591
2592     switch (atoi(args[0])) {
2593         case 0:
2594             ALOGI ("Connection on debug port: issuing reset.");
2595             issueLocalRequest(RIL_REQUEST_RESET_RADIO, NULL, 0);
2596             break;
2597         case 1:
2598             ALOGI ("Connection on debug port: issuing radio power off.");
2599             data = 0;
2600             issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2601             // Close the socket
2602             close(s_fdCommand);
2603             s_fdCommand = -1;
2604             break;
2605         case 2:
2606             ALOGI ("Debug port: issuing unsolicited voice network change.");
2607             RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
2608                                       NULL, 0);
2609             break;
2610         case 3:
2611             ALOGI ("Debug port: QXDM log enable.");
2612             qxdm_data[0] = 65536;     // head.func_tag
2613             qxdm_data[1] = 16;        // head.len
2614             qxdm_data[2] = 1;         // mode: 1 for 'start logging'
2615             qxdm_data[3] = 32;        // log_file_size: 32megabytes
2616             qxdm_data[4] = 0;         // log_mask
2617             qxdm_data[5] = 8;         // log_max_fileindex
2618             issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2619                               6 * sizeof(int));
2620             break;
2621         case 4:
2622             ALOGI ("Debug port: QXDM log disable.");
2623             qxdm_data[0] = 65536;
2624             qxdm_data[1] = 16;
2625             qxdm_data[2] = 0;          // mode: 0 for 'stop logging'
2626             qxdm_data[3] = 32;
2627             qxdm_data[4] = 0;
2628             qxdm_data[5] = 8;
2629             issueLocalRequest(RIL_REQUEST_OEM_HOOK_RAW, qxdm_data,
2630                               6 * sizeof(int));
2631             break;
2632         case 5:
2633             ALOGI("Debug port: Radio On");
2634             data = 1;
2635             issueLocalRequest(RIL_REQUEST_RADIO_POWER, &data, sizeof(int));
2636             sleep(2);
2637             // Set network selection automatic.
2638             issueLocalRequest(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, NULL, 0);
2639             break;
2640         case 6:
2641             ALOGI("Debug port: Setup Data Call, Apn :%s\n", args[1]);
2642             actData[0] = args[1];
2643             issueLocalRequest(RIL_REQUEST_SETUP_DATA_CALL, &actData,
2644                               sizeof(actData));
2645             break;
2646         case 7:
2647             ALOGI("Debug port: Deactivate Data Call");
2648             issueLocalRequest(RIL_REQUEST_DEACTIVATE_DATA_CALL, &deactData,
2649                               sizeof(deactData));
2650             break;
2651         case 8:
2652             ALOGI("Debug port: Dial Call");
2653             dialData.clir = 0;
2654             dialData.address = args[1];
2655             issueLocalRequest(RIL_REQUEST_DIAL, &dialData, sizeof(dialData));
2656             break;
2657         case 9:
2658             ALOGI("Debug port: Answer Call");
2659             issueLocalRequest(RIL_REQUEST_ANSWER, NULL, 0);
2660             break;
2661         case 10:
2662             ALOGI("Debug port: End Call");
2663             issueLocalRequest(RIL_REQUEST_HANGUP, &hangupData,
2664                               sizeof(hangupData));
2665             break;
2666         default:
2667             ALOGE ("Invalid request");
2668             break;
2669     }
2670     freeDebugCallbackArgs(number, args);
2671     close(acceptFD);
2672 }
2673
2674
2675 static void userTimerCallback (int fd, short flags, void *param) {
2676     UserCallbackInfo *p_info;
2677
2678     p_info = (UserCallbackInfo *)param;
2679
2680     p_info->p_callback(p_info->userParam);
2681
2682
2683     // FIXME generalize this...there should be a cancel mechanism
2684     if (s_last_wake_timeout_info != NULL && s_last_wake_timeout_info == p_info) {
2685         s_last_wake_timeout_info = NULL;
2686     }
2687
2688     free(p_info);
2689 }
2690
2691
2692 static void *
2693 eventLoop(void *param) {
2694     int ret;
2695     int filedes[2];
2696
2697     ril_event_init();
2698
2699     pthread_mutex_lock(&s_startupMutex);
2700
2701     s_started = 1;
2702     pthread_cond_broadcast(&s_startupCond);
2703
2704     pthread_mutex_unlock(&s_startupMutex);
2705
2706     ret = pipe(filedes);
2707
2708     if (ret < 0) {
2709         ALOGE("Error in pipe() errno:%d", errno);
2710         return NULL;
2711     }
2712
2713     s_fdWakeupRead = filedes[0];
2714     s_fdWakeupWrite = filedes[1];
2715
2716     fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);
2717
2718     ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
2719                 processWakeupCallback, NULL);
2720
2721     rilEventAddWakeup (&s_wakeupfd_event);
2722
2723     // Only returns on error
2724     ril_event_loop();
2725     ALOGE ("error in event_loop_base errno:%d", errno);
2726     // kill self to restart on error
2727     kill(0, SIGKILL);
2728
2729     return NULL;
2730 }
2731
2732 extern "C" void
2733 RIL_startEventLoop(void) {
2734     int ret;
2735     pthread_attr_t attr;
2736
2737     /* spin up eventLoop thread and wait for it to get started */
2738     s_started = 0;
2739     pthread_mutex_lock(&s_startupMutex);
2740
2741     pthread_attr_init (&attr);
2742     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2743     ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);
2744
2745     while (s_started == 0) {
2746         pthread_cond_wait(&s_startupCond, &s_startupMutex);
2747     }
2748
2749     pthread_mutex_unlock(&s_startupMutex);
2750
2751     if (ret < 0) {
2752         ALOGE("Failed to create dispatch thread errno:%d", errno);
2753         return;
2754     }
2755 }
2756
2757 // Used for testing purpose only.
2758 extern "C" void RIL_setcallbacks (const RIL_RadioFunctions *callbacks) {
2759     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2760 }
2761
2762 extern "C" void
2763 RIL_register (const RIL_RadioFunctions *callbacks) {
2764     int ret;
2765     int flags;
2766
2767     if (callbacks == NULL) {
2768         ALOGE("RIL_register: RIL_RadioFunctions * null");
2769         return;
2770     }
2771     if (callbacks->version < RIL_VERSION_MIN) {
2772         ALOGE("RIL_register: version %d is to old, min version is %d",
2773              callbacks->version, RIL_VERSION_MIN);
2774         return;
2775     }
2776     if (callbacks->version > RIL_VERSION) {
2777         ALOGE("RIL_register: version %d is too new, max version is %d",
2778              callbacks->version, RIL_VERSION);
2779         return;
2780     }
2781     ALOGE("RIL_register: RIL version %d", callbacks->version);
2782
2783     if (s_registerCalled > 0) {
2784         ALOGE("RIL_register has been called more than once. "
2785                 "Subsequent call ignored");
2786         return;
2787     }
2788
2789     memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));
2790
2791     s_registerCalled = 1;
2792
2793     // Little self-check
2794
2795     for (int i = 0; i < (int)NUM_ELEMS(s_commands); i++) {
2796         assert(i == s_commands[i].requestNumber);
2797     }
2798
2799     for (int i = 0; i < (int)NUM_ELEMS(s_unsolResponses); i++) {
2800         assert(i + RIL_UNSOL_RESPONSE_BASE
2801                 == s_unsolResponses[i].requestNumber);
2802     }
2803
2804     // New rild impl calls RIL_startEventLoop() first
2805     // old standalone impl wants it here.
2806
2807     if (s_started == 0) {
2808         RIL_startEventLoop();
2809     }
2810
2811     // start listen socket
2812
2813 #if 0
2814     ret = socket_local_server (SOCKET_NAME_RIL,
2815             ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
2816
2817     if (ret < 0) {
2818         ALOGE("Unable to bind socket errno:%d", errno);
2819         exit (-1);
2820     }
2821     s_fdListen = ret;
2822
2823 #else
2824     s_fdListen = android_get_control_socket(SOCKET_NAME_RIL);
2825     if (s_fdListen < 0) {
2826         ALOGE("Failed to get socket '" SOCKET_NAME_RIL "'");
2827         exit(-1);
2828     }
2829
2830     ret = listen(s_fdListen, 4);
2831
2832     if (ret < 0) {
2833         ALOGE("Failed to listen on control socket '%d': %s",
2834              s_fdListen, strerror(errno));
2835         exit(-1);
2836     }
2837 #endif
2838
2839
2840     /* note: non-persistent so we can accept only one connection at a time */
2841     ril_event_set (&s_listen_event, s_fdListen, false,
2842                 listenCallback, NULL);
2843
2844     rilEventAddWakeup (&s_listen_event);
2845
2846 #if 1
2847     // start debug interface socket
2848
2849     s_fdDebug = android_get_control_socket(SOCKET_NAME_RIL_DEBUG);
2850     if (s_fdDebug < 0) {
2851         ALOGE("Failed to get socket '" SOCKET_NAME_RIL_DEBUG "' errno:%d", errno);
2852         exit(-1);
2853     }
2854
2855     ret = listen(s_fdDebug, 4);
2856
2857     if (ret < 0) {
2858         ALOGE("Failed to listen on ril debug socket '%d': %s",
2859              s_fdDebug, strerror(errno));
2860         exit(-1);
2861     }
2862
2863     ril_event_set (&s_debug_event, s_fdDebug, true,
2864                 debugCallback, NULL);
2865
2866     rilEventAddWakeup (&s_debug_event);
2867 #endif
2868
2869 }
2870
2871 static int
2872 checkAndDequeueRequestInfo(struct RequestInfo *pRI) {
2873     int ret = 0;
2874
2875     if (pRI == NULL) {
2876         return 0;
2877     }
2878
2879     pthread_mutex_lock(&s_pendingRequestsMutex);
2880
2881     for(RequestInfo **ppCur = &s_pendingRequests
2882         ; *ppCur != NULL
2883         ; ppCur = &((*ppCur)->p_next)
2884     ) {
2885         if (pRI == *ppCur) {
2886             ret = 1;
2887
2888             *ppCur = (*ppCur)->p_next;
2889             break;
2890         }
2891     }
2892
2893     pthread_mutex_unlock(&s_pendingRequestsMutex);
2894
2895     return ret;
2896 }
2897
2898
2899 extern "C" void
2900 RIL_onRequestComplete(RIL_Token t, RIL_Errno e, void *response, size_t responselen) {
2901     RequestInfo *pRI;
2902     int ret;
2903     size_t errorOffset;
2904
2905     pRI = (RequestInfo *)t;
2906
2907     if (!checkAndDequeueRequestInfo(pRI)) {
2908         ALOGE ("RIL_onRequestComplete: invalid RIL_Token");
2909         return;
2910     }
2911
2912     if (pRI->local > 0) {
2913         // Locally issued command...void only!
2914         // response does not go back up the command socket
2915         ALOGD("C[locl]< %s", requestToString(pRI->pCI->requestNumber));
2916
2917         goto done;
2918     }
2919
2920     appendPrintBuf("[%04d]< %s",
2921         pRI->token, requestToString(pRI->pCI->requestNumber));
2922
2923     if (pRI->cancelled == 0) {
2924         Parcel p;
2925
2926         p.writeInt32 (RESPONSE_SOLICITED);
2927         p.writeInt32 (pRI->token);
2928         errorOffset = p.dataPosition();
2929
2930         p.writeInt32 (e);
2931
2932         if (response != NULL) {
2933             // there is a response payload, no matter success or not.
2934             ret = pRI->pCI->responseFunction(p, response, responselen);
2935
2936             /* if an error occurred, rewind and mark it */
2937             if (ret != 0) {
2938                 p.setDataPosition(errorOffset);
2939                 p.writeInt32 (ret);
2940             }
2941         }
2942
2943         if (e != RIL_E_SUCCESS) {
2944             appendPrintBuf("%s fails by %s", printBuf, failCauseToString(e));
2945         }
2946
2947         if (s_fdCommand < 0) {
2948             ALOGD ("RIL onRequestComplete: Command channel closed");
2949         }
2950         sendResponse(p);
2951     }
2952
2953 done:
2954     free(pRI);
2955 }
2956
2957
2958 static void
2959 grabPartialWakeLock() {
2960     acquire_wake_lock(PARTIAL_WAKE_LOCK, ANDROID_WAKE_LOCK_NAME);
2961 }
2962
2963 static void
2964 releaseWakeLock() {
2965     release_wake_lock(ANDROID_WAKE_LOCK_NAME);
2966 }
2967
2968 /**
2969  * Timer callback to put us back to sleep before the default timeout
2970  */
2971 static void
2972 wakeTimeoutCallback (void *param) {
2973     // We're using "param != NULL" as a cancellation mechanism
2974     if (param == NULL) {
2975         //ALOGD("wakeTimeout: releasing wake lock");
2976
2977         releaseWakeLock();
2978     } else {
2979         //ALOGD("wakeTimeout: releasing wake lock CANCELLED");
2980     }
2981 }
2982
2983 static int
2984 decodeVoiceRadioTechnology (RIL_RadioState radioState) {
2985     switch (radioState) {
2986         case RADIO_STATE_SIM_NOT_READY:
2987         case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
2988         case RADIO_STATE_SIM_READY:
2989             return RADIO_TECH_UMTS;
2990
2991         case RADIO_STATE_RUIM_NOT_READY:
2992         case RADIO_STATE_RUIM_READY:
2993         case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
2994         case RADIO_STATE_NV_NOT_READY:
2995         case RADIO_STATE_NV_READY:
2996             return RADIO_TECH_1xRTT;
2997
2998         default:
2999             ALOGD("decodeVoiceRadioTechnology: Invoked with incorrect RadioState");
3000             return -1;
3001     }
3002 }
3003
3004 static int
3005 decodeCdmaSubscriptionSource (RIL_RadioState radioState) {
3006     switch (radioState) {
3007         case RADIO_STATE_SIM_NOT_READY:
3008         case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
3009         case RADIO_STATE_SIM_READY:
3010         case RADIO_STATE_RUIM_NOT_READY:
3011         case RADIO_STATE_RUIM_READY:
3012         case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
3013             return CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM;
3014
3015         case RADIO_STATE_NV_NOT_READY:
3016         case RADIO_STATE_NV_READY:
3017             return CDMA_SUBSCRIPTION_SOURCE_NV;
3018
3019         default:
3020             ALOGD("decodeCdmaSubscriptionSource: Invoked with incorrect RadioState");
3021             return -1;
3022     }
3023 }
3024
3025 static int
3026 decodeSimStatus (RIL_RadioState radioState) {
3027    switch (radioState) {
3028        case RADIO_STATE_SIM_NOT_READY:
3029        case RADIO_STATE_RUIM_NOT_READY:
3030        case RADIO_STATE_NV_NOT_READY:
3031        case RADIO_STATE_NV_READY:
3032            return -1;
3033        case RADIO_STATE_SIM_LOCKED_OR_ABSENT:
3034        case RADIO_STATE_SIM_READY:
3035        case RADIO_STATE_RUIM_READY:
3036        case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:
3037            return radioState;
3038        default:
3039            ALOGD("decodeSimStatus: Invoked with incorrect RadioState");
3040            return -1;
3041    }
3042 }
3043
3044 static bool is3gpp2(int radioTech) {
3045     switch (radioTech) {
3046         case RADIO_TECH_IS95A:
3047         case RADIO_TECH_IS95B:
3048         case RADIO_TECH_1xRTT:
3049         case RADIO_TECH_EVDO_0:
3050         case RADIO_TECH_EVDO_A:
3051         case RADIO_TECH_EVDO_B:
3052         case RADIO_TECH_EHRPD:
3053             return true;
3054         default:
3055             return false;
3056     }
3057 }
3058
3059 /* If RIL sends SIM states or RUIM states, store the voice radio
3060  * technology and subscription source information so that they can be
3061  * returned when telephony framework requests them
3062  */
3063 static RIL_RadioState
3064 processRadioState(RIL_RadioState newRadioState) {
3065
3066     if((newRadioState > RADIO_STATE_UNAVAILABLE) && (newRadioState < RADIO_STATE_ON)) {
3067         int newVoiceRadioTech;
3068         int newCdmaSubscriptionSource;
3069         int newSimStatus;
3070
3071         /* This is old RIL. Decode Subscription source and Voice Radio Technology
3072            from Radio State and send change notifications if there has been a change */
3073         newVoiceRadioTech = decodeVoiceRadioTechnology(newRadioState);
3074         if(newVoiceRadioTech != voiceRadioTech) {
3075             voiceRadioTech = newVoiceRadioTech;
3076             RIL_onUnsolicitedResponse (RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
3077                         &voiceRadioTech, sizeof(voiceRadioTech));
3078         }
3079         if(is3gpp2(newVoiceRadioTech)) {
3080             newCdmaSubscriptionSource = decodeCdmaSubscriptionSource(newRadioState);
3081             if(newCdmaSubscriptionSource != cdmaSubscriptionSource) {
3082                 cdmaSubscriptionSource = newCdmaSubscriptionSource;
3083                 RIL_onUnsolicitedResponse (RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
3084                         &cdmaSubscriptionSource, sizeof(cdmaSubscriptionSource));
3085             }
3086         }
3087         newSimStatus = decodeSimStatus(newRadioState);
3088         if(newSimStatus != simRuimStatus) {
3089             simRuimStatus = newSimStatus;
3090             RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
3091         }
3092
3093         /* Send RADIO_ON to telephony */
3094         newRadioState = RADIO_STATE_ON;
3095     }
3096
3097     return newRadioState;
3098 }
3099
3100 extern "C"
3101 void RIL_onUnsolicitedResponse(int unsolResponse, void *data,
3102                                 size_t datalen)
3103 {
3104     int unsolResponseIndex;
3105     int ret;
3106     int64_t timeReceived = 0;
3107     bool shouldScheduleTimeout = false;
3108     RIL_RadioState newState;
3109
3110     if (s_registerCalled == 0) {
3111         // Ignore RIL_onUnsolicitedResponse before RIL_register
3112         ALOGW("RIL_onUnsolicitedResponse called before RIL_register");
3113         return;
3114     }
3115
3116     unsolResponseIndex = unsolResponse - RIL_UNSOL_RESPONSE_BASE;
3117
3118     if ((unsolResponseIndex < 0)
3119         || (unsolResponseIndex >= (int32_t)NUM_ELEMS(s_unsolResponses))) {
3120         ALOGE("unsupported unsolicited response code %d", unsolResponse);
3121         return;
3122     }
3123
3124     // Grab a wake lock if needed for this reponse,
3125     // as we exit we'll either release it immediately
3126     // or set a timer to release it later.
3127     switch (s_unsolResponses[unsolResponseIndex].wakeType) {
3128         case WAKE_PARTIAL:
3129             grabPartialWakeLock();
3130             shouldScheduleTimeout = true;
3131         break;
3132
3133         case DONT_WAKE:
3134         default:
3135             // No wake lock is grabed so don't set timeout
3136             shouldScheduleTimeout = false;
3137             break;
3138     }
3139
3140     // Mark the time this was received, doing this
3141     // after grabing the wakelock incase getting
3142     // the elapsedRealTime might cause us to goto
3143     // sleep.
3144     if (unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
3145         timeReceived = elapsedRealtime();
3146     }
3147
3148     appendPrintBuf("[UNSL]< %s", requestToString(unsolResponse));
3149
3150     Parcel p;
3151
3152     p.writeInt32 (RESPONSE_UNSOLICITED);
3153     p.writeInt32 (unsolResponse);
3154
3155     ret = s_unsolResponses[unsolResponseIndex]
3156                 .responseFunction(p, data, datalen);
3157     if (ret != 0) {
3158         // Problem with the response. Don't continue;
3159         goto error_exit;
3160     }
3161
3162     // some things get more payload
3163     switch(unsolResponse) {
3164         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
3165             newState = processRadioState(s_callbacks.onStateRequest());
3166             p.writeInt32(newState);
3167             appendPrintBuf("%s {%s}", printBuf,
3168                 radioStateToString(s_callbacks.onStateRequest()));
3169         break;
3170
3171
3172         case RIL_UNSOL_NITZ_TIME_RECEIVED:
3173             // Store the time that this was received so the
3174             // handler of this message can account for
3175             // the time it takes to arrive and process. In
3176             // particular the system has been known to sleep
3177             // before this message can be processed.
3178             p.writeInt64(timeReceived);
3179         break;
3180     }
3181
3182     ret = sendResponse(p);
3183     if (ret != 0 && unsolResponse == RIL_UNSOL_NITZ_TIME_RECEIVED) {
3184
3185         // Unfortunately, NITZ time is not poll/update like everything
3186         // else in the system. So, if the upstream client isn't connected,
3187         // keep a copy of the last NITZ response (with receive time noted
3188         // above) around so we can deliver it when it is connected
3189
3190         if (s_lastNITZTimeData != NULL) {
3191             free (s_lastNITZTimeData);
3192             s_lastNITZTimeData = NULL;
3193         }
3194
3195         s_lastNITZTimeData = malloc(p.dataSize());
3196         s_lastNITZTimeDataSize = p.dataSize();
3197         memcpy(s_lastNITZTimeData, p.data(), p.dataSize());
3198     }
3199
3200     // For now, we automatically go back to sleep after TIMEVAL_WAKE_TIMEOUT
3201     // FIXME The java code should handshake here to release wake lock
3202
3203     if (shouldScheduleTimeout) {
3204         // Cancel the previous request
3205         if (s_last_wake_timeout_info != NULL) {
3206             s_last_wake_timeout_info->userParam = (void *)1;
3207         }
3208
3209         s_last_wake_timeout_info
3210             = internalRequestTimedCallback(wakeTimeoutCallback, NULL,
3211                                             &TIMEVAL_WAKE_TIMEOUT);
3212     }
3213
3214     // Normal exit
3215     return;
3216
3217 error_exit:
3218     if (shouldScheduleTimeout) {
3219         releaseWakeLock();
3220     }
3221 }
3222
3223 /** FIXME generalize this if you track UserCAllbackInfo, clear it
3224     when the callback occurs
3225 */
3226 static UserCallbackInfo *
3227 internalRequestTimedCallback (RIL_TimedCallback callback, void *param,
3228                                 const struct timeval *relativeTime)
3229 {
3230     struct timeval myRelativeTime;
3231     UserCallbackInfo *p_info;
3232
3233     p_info = (UserCallbackInfo *) malloc (sizeof(UserCallbackInfo));
3234
3235     p_info->p_callback = callback;
3236     p_info->userParam = param;
3237
3238     if (relativeTime == NULL) {
3239         /* treat null parameter as a 0 relative time */
3240         memset (&myRelativeTime, 0, sizeof(myRelativeTime));
3241     } else {
3242         /* FIXME I think event_add's tv param is really const anyway */
3243         memcpy (&myRelativeTime, relativeTime, sizeof(myRelativeTime));
3244     }
3245
3246     ril_event_set(&(p_info->event), -1, false, userTimerCallback, p_info);
3247
3248     ril_timer_add(&(p_info->event), &myRelativeTime);
3249
3250     triggerEvLoop();
3251     return p_info;
3252 }
3253
3254
3255 extern "C" void
3256 RIL_requestTimedCallback (RIL_TimedCallback callback, void *param,
3257                                 const struct timeval *relativeTime) {
3258     internalRequestTimedCallback (callback, param, relativeTime);
3259 }
3260
3261 const char *
3262 failCauseToString(RIL_Errno e) {
3263     switch(e) {
3264         case RIL_E_SUCCESS: return "E_SUCCESS";
3265         case RIL_E_RADIO_NOT_AVAILABLE: return "E_RAIDO_NOT_AVAILABLE";
3266         case RIL_E_GENERIC_FAILURE: return "E_GENERIC_FAILURE";
3267         case RIL_E_PASSWORD_INCORRECT: return "E_PASSWORD_INCORRECT";
3268         case RIL_E_SIM_PIN2: return "E_SIM_PIN2";
3269         case RIL_E_SIM_PUK2: return "E_SIM_PUK2";
3270         case RIL_E_REQUEST_NOT_SUPPORTED: return "E_REQUEST_NOT_SUPPORTED";
3271         case RIL_E_CANCELLED: return "E_CANCELLED";
3272         case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "E_OP_NOT_ALLOWED_DURING_VOICE_CALL";
3273         case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
3274         case RIL_E_SMS_SEND_FAIL_RETRY: return "E_SMS_SEND_FAIL_RETRY";
3275         case RIL_E_SIM_ABSENT:return "E_SIM_ABSENT";
3276         case RIL_E_ILLEGAL_SIM_OR_ME:return "E_ILLEGAL_SIM_OR_ME";
3277 #ifdef FEATURE_MULTIMODE_ANDROID
3278         case RIL_E_SUBSCRIPTION_NOT_AVAILABLE:return "E_SUBSCRIPTION_NOT_AVAILABLE";
3279         case RIL_E_MODE_NOT_SUPPORTED:return "E_MODE_NOT_SUPPORTED";
3280 #endif
3281         default: return "<unknown error>";
3282     }
3283 }
3284
3285 const char *
3286 radioStateToString(RIL_RadioState s) {
3287     switch(s) {
3288         case RADIO_STATE_OFF: return "RADIO_OFF";
3289         case RADIO_STATE_UNAVAILABLE: return "RADIO_UNAVAILABLE";
3290         case RADIO_STATE_SIM_NOT_READY: return "RADIO_SIM_NOT_READY";
3291         case RADIO_STATE_SIM_LOCKED_OR_ABSENT: return "RADIO_SIM_LOCKED_OR_ABSENT";
3292         case RADIO_STATE_SIM_READY: return "RADIO_SIM_READY";
3293         case RADIO_STATE_RUIM_NOT_READY:return"RADIO_RUIM_NOT_READY";
3294         case RADIO_STATE_RUIM_READY:return"RADIO_RUIM_READY";
3295         case RADIO_STATE_RUIM_LOCKED_OR_ABSENT:return"RADIO_RUIM_LOCKED_OR_ABSENT";
3296         case RADIO_STATE_NV_NOT_READY:return"RADIO_NV_NOT_READY";
3297         case RADIO_STATE_NV_READY:return"RADIO_NV_READY";
3298         case RADIO_STATE_ON:return"RADIO_ON";
3299         default: return "<unknown state>";
3300     }
3301 }
3302
3303 const char *
3304 callStateToString(RIL_CallState s) {
3305     switch(s) {
3306         case RIL_CALL_ACTIVE : return "ACTIVE";
3307         case RIL_CALL_HOLDING: return "HOLDING";
3308         case RIL_CALL_DIALING: return "DIALING";
3309         case RIL_CALL_ALERTING: return "ALERTING";
3310         case RIL_CALL_INCOMING: return "INCOMING";
3311         case RIL_CALL_WAITING: return "WAITING";
3312         default: return "<unknown state>";
3313     }
3314 }
3315
3316 const char *
3317 requestToString(int request) {
3318 /*
3319  cat libs/telephony/ril_commands.h \
3320  | egrep "^ *{RIL_" \
3321  | sed -re 's/\{RIL_([^,]+),[^,]+,([^}]+).+/case RIL_\1: return "\1";/'
3322
3323
3324  cat libs/telephony/ril_unsol_commands.h \
3325  | egrep "^ *{RIL_" \
3326  | sed -re 's/\{RIL_([^,]+),([^}]+).+/case RIL_\1: return "\1";/'
3327
3328 */
3329     switch(request) {
3330         case RIL_REQUEST_GET_SIM_STATUS: return "GET_SIM_STATUS";
3331         case RIL_REQUEST_ENTER_SIM_PIN: return "ENTER_SIM_PIN";
3332         case RIL_REQUEST_ENTER_SIM_PUK: return "ENTER_SIM_PUK";
3333         case RIL_REQUEST_ENTER_SIM_PIN2: return "ENTER_SIM_PIN2";
3334         case RIL_REQUEST_ENTER_SIM_PUK2: return "ENTER_SIM_PUK2";
3335         case RIL_REQUEST_CHANGE_SIM_PIN: return "CHANGE_SIM_PIN";
3336         case RIL_REQUEST_CHANGE_SIM_PIN2: return "CHANGE_SIM_PIN2";
3337         case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: return "ENTER_NETWORK_DEPERSONALIZATION";
3338         case RIL_REQUEST_GET_CURRENT_CALLS: return "GET_CURRENT_CALLS";
3339         case RIL_REQUEST_DIAL: return "DIAL";
3340         case RIL_REQUEST_GET_IMSI: return "GET_IMSI";
3341         case RIL_REQUEST_HANGUP: return "HANGUP";
3342         case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: return "HANGUP_WAITING_OR_BACKGROUND";
3343         case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: return "HANGUP_FOREGROUND_RESUME_BACKGROUND";
3344         case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: return "SWITCH_WAITING_OR_HOLDING_AND_ACTIVE";
3345         case RIL_REQUEST_CONFERENCE: return "CONFERENCE";
3346         case RIL_REQUEST_UDUB: return "UDUB";
3347         case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: return "LAST_CALL_FAIL_CAUSE";
3348         case RIL_REQUEST_SIGNAL_STRENGTH: return "SIGNAL_STRENGTH";
3349         case RIL_REQUEST_VOICE_REGISTRATION_STATE: return "VOICE_REGISTRATION_STATE";
3350         case RIL_REQUEST_DATA_REGISTRATION_STATE: return "DATA_REGISTRATION_STATE";
3351         case RIL_REQUEST_OPERATOR: return "OPERATOR";
3352         case RIL_REQUEST_RADIO_POWER: return "RADIO_POWER";
3353         case RIL_REQUEST_DTMF: return "DTMF";
3354         case RIL_REQUEST_SEND_SMS: return "SEND_SMS";
3355         case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE";
3356         case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL";
3357         case RIL_REQUEST_SIM_IO: return "SIM_IO";
3358         case RIL_REQUEST_SEND_USSD: return "SEND_USSD";
3359         case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD";
3360         case RIL_REQUEST_GET_CLIR: return "GET_CLIR";
3361         case RIL_REQUEST_SET_CLIR: return "SET_CLIR";
3362         case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: return "QUERY_CALL_FORWARD_STATUS";
3363         case RIL_REQUEST_SET_CALL_FORWARD: return "SET_CALL_FORWARD";
3364         case RIL_REQUEST_QUERY_CALL_WAITING: return "QUERY_CALL_WAITING";
3365         case RIL_REQUEST_SET_CALL_WAITING: return "SET_CALL_WAITING";
3366         case RIL_REQUEST_SMS_ACKNOWLEDGE: return "SMS_ACKNOWLEDGE";
3367         case RIL_REQUEST_GET_IMEI: return "GET_IMEI";
3368         case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV";
3369         case RIL_REQUEST_ANSWER: return "ANSWER";
3370         case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL";
3371         case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK";
3372         case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK";
3373         case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD";
3374         case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: return "QUERY_NETWORK_SELECTION_MODE";
3375         case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: return "SET_NETWORK_SELECTION_AUTOMATIC";
3376         case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: return "SET_NETWORK_SELECTION_MANUAL";
3377         case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS : return "QUERY_AVAILABLE_NETWORKS ";
3378         case RIL_REQUEST_DTMF_START: return "DTMF_START";
3379         case RIL_REQUEST_DTMF_STOP: return "DTMF_STOP";
3380         case RIL_REQUEST_BASEBAND_VERSION: return "BASEBAND_VERSION";
3381         case RIL_REQUEST_SEPARATE_CONNECTION: return "SEPARATE_CONNECTION";
3382         case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: return "SET_PREFERRED_NETWORK_TYPE";
3383         case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "GET_PREFERRED_NETWORK_TYPE";
3384         case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "GET_NEIGHBORING_CELL_IDS";
3385         case RIL_REQUEST_SET_MUTE: return "SET_MUTE";
3386         case RIL_REQUEST_GET_MUTE: return "GET_MUTE";
3387         case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP";
3388         case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE";
3389         case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST";
3390         case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO";
3391         case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW";
3392         case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS";
3393         case RIL_REQUEST_SET_BAND_MODE: return "SET_BAND_MODE";
3394         case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: return "QUERY_AVAILABLE_BAND_MODE";
3395         case RIL_REQUEST_STK_GET_PROFILE: return "STK_GET_PROFILE";
3396         case RIL_REQUEST_STK_SET_PROFILE: return "STK_SET_PROFILE";
3397         case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: return "STK_SEND_ENVELOPE_COMMAND";
3398         case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: return "STK_SEND_TERMINAL_RESPONSE";
3399         case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: return "STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
3400         case RIL_REQUEST_SCREEN_STATE: return "SCREEN_STATE";
3401         case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: return "EXPLICIT_CALL_TRANSFER";
3402         case RIL_REQUEST_SET_LOCATION_UPDATES: return "SET_LOCATION_UPDATES";
3403         case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:return"CDMA_SET_SUBSCRIPTION_SOURCE";
3404         case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:return"CDMA_SET_ROAMING_PREFERENCE";
3405         case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:return"CDMA_QUERY_ROAMING_PREFERENCE";
3406         case RIL_REQUEST_SET_TTY_MODE:return"SET_TTY_MODE";
3407         case RIL_REQUEST_QUERY_TTY_MODE:return"QUERY_TTY_MODE";
3408         case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
3409         case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:return"CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
3410         case RIL_REQUEST_CDMA_FLASH:return"CDMA_FLASH";
3411         case RIL_REQUEST_CDMA_BURST_DTMF:return"CDMA_BURST_DTMF";
3412         case RIL_REQUEST_CDMA_SEND_SMS:return"CDMA_SEND_SMS";
3413         case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:return"CDMA_SMS_ACKNOWLEDGE";
3414         case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:return"GSM_GET_BROADCAST_SMS_CONFIG";
3415         case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:return"GSM_SET_BROADCAST_SMS_CONFIG";
3416         case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:return "CDMA_GET_BROADCAST_SMS_CONFIG";
3417         case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:return "CDMA_SET_BROADCAST_SMS_CONFIG";
3418         case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:return "CDMA_SMS_BROADCAST_ACTIVATION";
3419         case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY: return"CDMA_VALIDATE_AND_WRITE_AKEY";
3420         case RIL_REQUEST_CDMA_SUBSCRIPTION: return"CDMA_SUBSCRIPTION";
3421         case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "CDMA_WRITE_SMS_TO_RUIM";
3422         case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "CDMA_DELETE_SMS_ON_RUIM";
3423         case RIL_REQUEST_DEVICE_IDENTITY: return "DEVICE_IDENTITY";
3424         case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: return "EXIT_EMERGENCY_CALLBACK_MODE";
3425         case RIL_REQUEST_GET_SMSC_ADDRESS: return "GET_SMSC_ADDRESS";
3426         case RIL_REQUEST_SET_SMSC_ADDRESS: return "SET_SMSC_ADDRESS";
3427         case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: return "REPORT_SMS_MEMORY_STATUS";
3428         case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING: return "REPORT_STK_SERVICE_IS_RUNNING";
3429         case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: return "CDMA_GET_SUBSCRIPTION_SOURCE";
3430         case RIL_REQUEST_ISIM_AUTHENTICATION: return "ISIM_AUTHENTICATION";
3431         case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU: return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
3432         case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS: return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
3433         case RIL_REQUEST_VOICE_RADIO_TECH: return "VOICE_RADIO_TECH";
3434         case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
3435         case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
3436         case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
3437         case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
3438         case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
3439         case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
3440         case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
3441         case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
3442         case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
3443         case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
3444         case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
3445         case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
3446         case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
3447         case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
3448         case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
3449         case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
3450         case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
3451         case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
3452         case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
3453         case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
3454         case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
3455         case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
3456         case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
3457         case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
3458         case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
3459         case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
3460         case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
3461         case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
3462         case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
3463         case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
3464         case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
3465         case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
3466         case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
3467         case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
3468         case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: return "UNSOL_VOICE_RADIO_TECH_CHANGED";
3469         default: return "<unknown request>";
3470     }
3471 }
3472
3473 } /* namespace android */