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